xref: /third_party/rust/crates/syn/src/gen/debug.rs

// This file is @generated by syn-internal-codegen.
// It is not intended for manual editing.

use crate::*;
use std::fmt::{self, Debug};
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Abi {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Abi");
        formatter.field("extern_token", &self.extern_token);
        formatter.field("name", &self.name);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for AngleBracketedGenericArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl AngleBracketedGenericArguments {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("colon2_token", &self.colon2_token);
                formatter.field("lt_token", &self.lt_token);
                formatter.field("args", &self.args);
                formatter.field("gt_token", &self.gt_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "AngleBracketedGenericArguments")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Arm {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Arm");
        formatter.field("attrs", &self.attrs);
        formatter.field("pat", &self.pat);
        formatter.field("guard", &self.guard);
        formatter.field("fat_arrow_token", &self.fat_arrow_token);
        formatter.field("body", &self.body);
        formatter.field("comma", &self.comma);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for AssocConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("AssocConst");
        formatter.field("ident", &self.ident);
        formatter.field("generics", &self.generics);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("value", &self.value);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for AssocType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("AssocType");
        formatter.field("ident", &self.ident);
        formatter.field("generics", &self.generics);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for AttrStyle {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("AttrStyle::")?;
        match self {
            AttrStyle::Outer => formatter.write_str("Outer"),
            AttrStyle::Inner(v0) => {
                let mut formatter = formatter.debug_tuple("Inner");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Attribute {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Attribute");
        formatter.field("pound_token", &self.pound_token);
        formatter.field("style", &self.style);
        formatter.field("bracket_token", &self.bracket_token);
        formatter.field("meta", &self.meta);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for BareFnArg {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("BareFnArg");
        formatter.field("attrs", &self.attrs);
        formatter.field("name", &self.name);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for BareVariadic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("BareVariadic");
        formatter.field("attrs", &self.attrs);
        formatter.field("name", &self.name);
        formatter.field("dots", &self.dots);
        formatter.field("comma", &self.comma);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for BinOp {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("BinOp::")?;
        match self {
            BinOp::Add(v0) => {
                let mut formatter = formatter.debug_tuple("Add");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Sub(v0) => {
                let mut formatter = formatter.debug_tuple("Sub");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Mul(v0) => {
                let mut formatter = formatter.debug_tuple("Mul");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Div(v0) => {
                let mut formatter = formatter.debug_tuple("Div");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Rem(v0) => {
                let mut formatter = formatter.debug_tuple("Rem");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::And(v0) => {
                let mut formatter = formatter.debug_tuple("And");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Or(v0) => {
                let mut formatter = formatter.debug_tuple("Or");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitXor(v0) => {
                let mut formatter = formatter.debug_tuple("BitXor");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitAnd(v0) => {
                let mut formatter = formatter.debug_tuple("BitAnd");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitOr(v0) => {
                let mut formatter = formatter.debug_tuple("BitOr");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Shl(v0) => {
                let mut formatter = formatter.debug_tuple("Shl");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Shr(v0) => {
                let mut formatter = formatter.debug_tuple("Shr");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Eq(v0) => {
                let mut formatter = formatter.debug_tuple("Eq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Lt(v0) => {
                let mut formatter = formatter.debug_tuple("Lt");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Le(v0) => {
                let mut formatter = formatter.debug_tuple("Le");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Ne(v0) => {
                let mut formatter = formatter.debug_tuple("Ne");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Ge(v0) => {
                let mut formatter = formatter.debug_tuple("Ge");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::Gt(v0) => {
                let mut formatter = formatter.debug_tuple("Gt");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::AddAssign(v0) => {
                let mut formatter = formatter.debug_tuple("AddAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::SubAssign(v0) => {
                let mut formatter = formatter.debug_tuple("SubAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::MulAssign(v0) => {
                let mut formatter = formatter.debug_tuple("MulAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::DivAssign(v0) => {
                let mut formatter = formatter.debug_tuple("DivAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::RemAssign(v0) => {
                let mut formatter = formatter.debug_tuple("RemAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitXorAssign(v0) => {
                let mut formatter = formatter.debug_tuple("BitXorAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitAndAssign(v0) => {
                let mut formatter = formatter.debug_tuple("BitAndAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitOrAssign(v0) => {
                let mut formatter = formatter.debug_tuple("BitOrAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::ShlAssign(v0) => {
                let mut formatter = formatter.debug_tuple("ShlAssign");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::ShrAssign(v0) => {
                let mut formatter = formatter.debug_tuple("ShrAssign");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Block {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Block");
        formatter.field("brace_token", &self.brace_token);
        formatter.field("stmts", &self.stmts);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for BoundLifetimes {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("BoundLifetimes");
        formatter.field("for_token", &self.for_token);
        formatter.field("lt_token", &self.lt_token);
        formatter.field("lifetimes", &self.lifetimes);
        formatter.field("gt_token", &self.gt_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ConstParam {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ConstParam");
        formatter.field("attrs", &self.attrs);
        formatter.field("const_token", &self.const_token);
        formatter.field("ident", &self.ident);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("default", &self.default);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Constraint {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Constraint");
        formatter.field("ident", &self.ident);
        formatter.field("generics", &self.generics);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(feature = "derive")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Data {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Data::")?;
        match self {
            Data::Struct(v0) => v0.debug(formatter, "Struct"),
            Data::Enum(v0) => v0.debug(formatter, "Enum"),
            Data::Union(v0) => v0.debug(formatter, "Union"),
        }
    }
}
#[cfg(feature = "derive")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for DataEnum {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl DataEnum {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("enum_token", &self.enum_token);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("variants", &self.variants);
                formatter.finish()
            }
        }
        self.debug(formatter, "DataEnum")
    }
}
#[cfg(feature = "derive")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for DataStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl DataStruct {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("struct_token", &self.struct_token);
                formatter.field("fields", &self.fields);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "DataStruct")
    }
}
#[cfg(feature = "derive")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for DataUnion {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl DataUnion {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("union_token", &self.union_token);
                formatter.field("fields", &self.fields);
                formatter.finish()
            }
        }
        self.debug(formatter, "DataUnion")
    }
}
#[cfg(feature = "derive")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for DeriveInput {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("DeriveInput");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("ident", &self.ident);
        formatter.field("generics", &self.generics);
        formatter.field("data", &self.data);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Expr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Expr::")?;
        match self {
            #[cfg(feature = "full")]
            Expr::Array(v0) => v0.debug(formatter, "Array"),
            #[cfg(feature = "full")]
            Expr::Assign(v0) => v0.debug(formatter, "Assign"),
            #[cfg(feature = "full")]
            Expr::Async(v0) => v0.debug(formatter, "Async"),
            #[cfg(feature = "full")]
            Expr::Await(v0) => v0.debug(formatter, "Await"),
            Expr::Binary(v0) => v0.debug(formatter, "Binary"),
            #[cfg(feature = "full")]
            Expr::Block(v0) => v0.debug(formatter, "Block"),
            #[cfg(feature = "full")]
            Expr::Break(v0) => v0.debug(formatter, "Break"),
            Expr::Call(v0) => v0.debug(formatter, "Call"),
            Expr::Cast(v0) => v0.debug(formatter, "Cast"),
            #[cfg(feature = "full")]
            Expr::Closure(v0) => v0.debug(formatter, "Closure"),
            #[cfg(feature = "full")]
            Expr::Const(v0) => v0.debug(formatter, "Const"),
            #[cfg(feature = "full")]
            Expr::Continue(v0) => v0.debug(formatter, "Continue"),
            Expr::Field(v0) => v0.debug(formatter, "Field"),
            #[cfg(feature = "full")]
            Expr::ForLoop(v0) => v0.debug(formatter, "ForLoop"),
            Expr::Group(v0) => v0.debug(formatter, "Group"),
            #[cfg(feature = "full")]
            Expr::If(v0) => v0.debug(formatter, "If"),
            Expr::Index(v0) => v0.debug(formatter, "Index"),
            #[cfg(feature = "full")]
            Expr::Infer(v0) => v0.debug(formatter, "Infer"),
            #[cfg(feature = "full")]
            Expr::Let(v0) => v0.debug(formatter, "Let"),
            Expr::Lit(v0) => v0.debug(formatter, "Lit"),
            #[cfg(feature = "full")]
            Expr::Loop(v0) => v0.debug(formatter, "Loop"),
            Expr::Macro(v0) => v0.debug(formatter, "Macro"),
            #[cfg(feature = "full")]
            Expr::Match(v0) => v0.debug(formatter, "Match"),
            Expr::MethodCall(v0) => v0.debug(formatter, "MethodCall"),
            Expr::Paren(v0) => v0.debug(formatter, "Paren"),
            Expr::Path(v0) => v0.debug(formatter, "Path"),
            #[cfg(feature = "full")]
            Expr::Range(v0) => v0.debug(formatter, "Range"),
            Expr::Reference(v0) => v0.debug(formatter, "Reference"),
            #[cfg(feature = "full")]
            Expr::Repeat(v0) => v0.debug(formatter, "Repeat"),
            #[cfg(feature = "full")]
            Expr::Return(v0) => v0.debug(formatter, "Return"),
            Expr::Struct(v0) => v0.debug(formatter, "Struct"),
            #[cfg(feature = "full")]
            Expr::Try(v0) => v0.debug(formatter, "Try"),
            #[cfg(feature = "full")]
            Expr::TryBlock(v0) => v0.debug(formatter, "TryBlock"),
            #[cfg(feature = "full")]
            Expr::Tuple(v0) => v0.debug(formatter, "Tuple"),
            Expr::Unary(v0) => v0.debug(formatter, "Unary"),
            #[cfg(feature = "full")]
            Expr::Unsafe(v0) => v0.debug(formatter, "Unsafe"),
            Expr::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::While(v0) => v0.debug(formatter, "While"),
            #[cfg(feature = "full")]
            Expr::Yield(v0) => v0.debug(formatter, "Yield"),
            #[cfg(not(feature = "full"))]
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprArray {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprArray {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprArray")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprAssign {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprAssign {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("left", &self.left);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("right", &self.right);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprAssign")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprAsync {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprAsync {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("async_token", &self.async_token);
                formatter.field("capture", &self.capture);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprAsync")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprAwait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprAwait {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("base", &self.base);
                formatter.field("dot_token", &self.dot_token);
                formatter.field("await_token", &self.await_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprAwait")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprBinary {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprBinary {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("left", &self.left);
                formatter.field("op", &self.op);
                formatter.field("right", &self.right);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprBinary")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprBlock {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprBlock {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("label", &self.label);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprBlock")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprBreak {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprBreak {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("break_token", &self.break_token);
                formatter.field("label", &self.label);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprBreak")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprCall {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprCall {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("func", &self.func);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("args", &self.args);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprCall")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprCast {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprCast {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("expr", &self.expr);
                formatter.field("as_token", &self.as_token);
                formatter.field("ty", &self.ty);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprCast")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprClosure {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprClosure {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("lifetimes", &self.lifetimes);
                formatter.field("constness", &self.constness);
                formatter.field("movability", &self.movability);
                formatter.field("asyncness", &self.asyncness);
                formatter.field("capture", &self.capture);
                formatter.field("or1_token", &self.or1_token);
                formatter.field("inputs", &self.inputs);
                formatter.field("or2_token", &self.or2_token);
                formatter.field("output", &self.output);
                formatter.field("body", &self.body);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprClosure")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprConst {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("const_token", &self.const_token);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprConst")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprContinue {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprContinue {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("continue_token", &self.continue_token);
                formatter.field("label", &self.label);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprContinue")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprField {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprField {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("base", &self.base);
                formatter.field("dot_token", &self.dot_token);
                formatter.field("member", &self.member);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprField")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprForLoop {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprForLoop {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("label", &self.label);
                formatter.field("for_token", &self.for_token);
                formatter.field("pat", &self.pat);
                formatter.field("in_token", &self.in_token);
                formatter.field("expr", &self.expr);
                formatter.field("body", &self.body);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprForLoop")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprGroup {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprGroup {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("group_token", &self.group_token);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprGroup")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprIf {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprIf {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("if_token", &self.if_token);
                formatter.field("cond", &self.cond);
                formatter.field("then_branch", &self.then_branch);
                formatter.field("else_branch", &self.else_branch);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprIf")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprIndex {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprIndex {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("expr", &self.expr);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("index", &self.index);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprIndex")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprInfer {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprInfer {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("underscore_token", &self.underscore_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprInfer")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprLet {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprLet {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("let_token", &self.let_token);
                formatter.field("pat", &self.pat);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprLet")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprLit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprLit {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("lit", &self.lit);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprLit")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprLoop {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprLoop {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("label", &self.label);
                formatter.field("loop_token", &self.loop_token);
                formatter.field("body", &self.body);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprLoop")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("mac", &self.mac);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprMacro")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprMatch {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprMatch {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("match_token", &self.match_token);
                formatter.field("expr", &self.expr);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("arms", &self.arms);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprMatch")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprMethodCall {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprMethodCall {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("receiver", &self.receiver);
                formatter.field("dot_token", &self.dot_token);
                formatter.field("method", &self.method);
                formatter.field("turbofish", &self.turbofish);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("args", &self.args);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprMethodCall")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprParen {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprParen {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprParen")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprPath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprPath {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("qself", &self.qself);
                formatter.field("path", &self.path);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprPath")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprRange {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprRange {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("start", &self.start);
                formatter.field("limits", &self.limits);
                formatter.field("end", &self.end);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprRange")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprReference {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("and_token", &self.and_token);
                formatter.field("mutability", &self.mutability);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprReference")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprRepeat {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprRepeat {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("expr", &self.expr);
                formatter.field("semi_token", &self.semi_token);
                formatter.field("len", &self.len);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprRepeat")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprReturn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprReturn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("return_token", &self.return_token);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprReturn")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprStruct {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("qself", &self.qself);
                formatter.field("path", &self.path);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("fields", &self.fields);
                formatter.field("dot2_token", &self.dot2_token);
                formatter.field("rest", &self.rest);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprStruct")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprTry {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprTry {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("expr", &self.expr);
                formatter.field("question_token", &self.question_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprTry")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprTryBlock {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprTryBlock {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("try_token", &self.try_token);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprTryBlock")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprTuple {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprTuple")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprUnary {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprUnary {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("op", &self.op);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprUnary")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprUnsafe {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprUnsafe {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("unsafe_token", &self.unsafe_token);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprUnsafe")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprWhile {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprWhile {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("label", &self.label);
                formatter.field("while_token", &self.while_token);
                formatter.field("cond", &self.cond);
                formatter.field("body", &self.body);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprWhile")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ExprYield {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ExprYield {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("yield_token", &self.yield_token);
                formatter.field("expr", &self.expr);
                formatter.finish()
            }
        }
        self.debug(formatter, "ExprYield")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Field {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Field");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("mutability", &self.mutability);
        formatter.field("ident", &self.ident);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FieldMutability {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("FieldMutability::")?;
        match self {
            FieldMutability::None => formatter.write_str("None"),
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FieldPat {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("FieldPat");
        formatter.field("attrs", &self.attrs);
        formatter.field("member", &self.member);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("pat", &self.pat);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FieldValue {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("FieldValue");
        formatter.field("attrs", &self.attrs);
        formatter.field("member", &self.member);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Fields {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Fields::")?;
        match self {
            Fields::Named(v0) => v0.debug(formatter, "Named"),
            Fields::Unnamed(v0) => v0.debug(formatter, "Unnamed"),
            Fields::Unit => formatter.write_str("Unit"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FieldsNamed {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl FieldsNamed {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("named", &self.named);
                formatter.finish()
            }
        }
        self.debug(formatter, "FieldsNamed")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FieldsUnnamed {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl FieldsUnnamed {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("unnamed", &self.unnamed);
                formatter.finish()
            }
        }
        self.debug(formatter, "FieldsUnnamed")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for File {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("File");
        formatter.field("shebang", &self.shebang);
        formatter.field("attrs", &self.attrs);
        formatter.field("items", &self.items);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for FnArg {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("FnArg::")?;
        match self {
            FnArg::Receiver(v0) => {
                let mut formatter = formatter.debug_tuple("Receiver");
                formatter.field(v0);
                formatter.finish()
            }
            FnArg::Typed(v0) => {
                let mut formatter = formatter.debug_tuple("Typed");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ForeignItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("ForeignItem::")?;
        match self {
            ForeignItem::Fn(v0) => v0.debug(formatter, "Fn"),
            ForeignItem::Static(v0) => v0.debug(formatter, "Static"),
            ForeignItem::Type(v0) => v0.debug(formatter, "Type"),
            ForeignItem::Macro(v0) => v0.debug(formatter, "Macro"),
            ForeignItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ForeignItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ForeignItemFn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("sig", &self.sig);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ForeignItemFn")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ForeignItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ForeignItemMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("mac", &self.mac);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ForeignItemMacro")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ForeignItemStatic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ForeignItemStatic {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("static_token", &self.static_token);
                formatter.field("mutability", &self.mutability);
                formatter.field("ident", &self.ident);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ForeignItemStatic")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ForeignItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ForeignItemType {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("type_token", &self.type_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ForeignItemType")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for GenericArgument {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("GenericArgument::")?;
        match self {
            GenericArgument::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::AssocType(v0) => {
                let mut formatter = formatter.debug_tuple("AssocType");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::AssocConst(v0) => {
                let mut formatter = formatter.debug_tuple("AssocConst");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::Constraint(v0) => {
                let mut formatter = formatter.debug_tuple("Constraint");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for GenericParam {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("GenericParam::")?;
        match self {
            GenericParam::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                formatter.field(v0);
                formatter.finish()
            }
            GenericParam::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            GenericParam::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Generics {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Generics");
        formatter.field("lt_token", &self.lt_token);
        formatter.field("params", &self.params);
        formatter.field("gt_token", &self.gt_token);
        formatter.field("where_clause", &self.where_clause);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("ImplItem::")?;
        match self {
            ImplItem::Const(v0) => v0.debug(formatter, "Const"),
            ImplItem::Fn(v0) => v0.debug(formatter, "Fn"),
            ImplItem::Type(v0) => v0.debug(formatter, "Type"),
            ImplItem::Macro(v0) => v0.debug(formatter, "Macro"),
            ImplItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ImplItemConst {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("defaultness", &self.defaultness);
                formatter.field("const_token", &self.const_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("expr", &self.expr);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ImplItemConst")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ImplItemFn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("defaultness", &self.defaultness);
                formatter.field("sig", &self.sig);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ImplItemFn")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ImplItemMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("mac", &self.mac);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ImplItemMacro")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ImplItemType {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("defaultness", &self.defaultness);
                formatter.field("type_token", &self.type_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("ty", &self.ty);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ImplItemType")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ImplRestriction {
    fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
        match *self {}
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Index {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Index");
        formatter.field("index", &self.index);
        formatter.field("span", &self.span);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Item {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Item::")?;
        match self {
            Item::Const(v0) => v0.debug(formatter, "Const"),
            Item::Enum(v0) => v0.debug(formatter, "Enum"),
            Item::ExternCrate(v0) => v0.debug(formatter, "ExternCrate"),
            Item::Fn(v0) => v0.debug(formatter, "Fn"),
            Item::ForeignMod(v0) => v0.debug(formatter, "ForeignMod"),
            Item::Impl(v0) => v0.debug(formatter, "Impl"),
            Item::Macro(v0) => v0.debug(formatter, "Macro"),
            Item::Mod(v0) => v0.debug(formatter, "Mod"),
            Item::Static(v0) => v0.debug(formatter, "Static"),
            Item::Struct(v0) => v0.debug(formatter, "Struct"),
            Item::Trait(v0) => v0.debug(formatter, "Trait"),
            Item::TraitAlias(v0) => v0.debug(formatter, "TraitAlias"),
            Item::Type(v0) => v0.debug(formatter, "Type"),
            Item::Union(v0) => v0.debug(formatter, "Union"),
            Item::Use(v0) => v0.debug(formatter, "Use"),
            Item::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemConst {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("const_token", &self.const_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("expr", &self.expr);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemConst")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemEnum {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemEnum {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("enum_token", &self.enum_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("variants", &self.variants);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemEnum")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemExternCrate {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemExternCrate {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("extern_token", &self.extern_token);
                formatter.field("crate_token", &self.crate_token);
                formatter.field("ident", &self.ident);
                formatter.field("rename", &self.rename);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemExternCrate")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemFn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("sig", &self.sig);
                formatter.field("block", &self.block);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemFn")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemForeignMod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemForeignMod {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("unsafety", &self.unsafety);
                formatter.field("abi", &self.abi);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("items", &self.items);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemForeignMod")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemImpl {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemImpl {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("defaultness", &self.defaultness);
                formatter.field("unsafety", &self.unsafety);
                formatter.field("impl_token", &self.impl_token);
                formatter.field("generics", &self.generics);
                formatter.field("trait_", &self.trait_);
                formatter.field("self_ty", &self.self_ty);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("items", &self.items);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemImpl")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("ident", &self.ident);
                formatter.field("mac", &self.mac);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemMacro")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemMod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemMod {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("unsafety", &self.unsafety);
                formatter.field("mod_token", &self.mod_token);
                formatter.field("ident", &self.ident);
                formatter.field("content", &self.content);
                formatter.field("semi", &self.semi);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemMod")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemStatic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemStatic {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("static_token", &self.static_token);
                formatter.field("mutability", &self.mutability);
                formatter.field("ident", &self.ident);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("expr", &self.expr);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemStatic")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemStruct {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("struct_token", &self.struct_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("fields", &self.fields);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemStruct")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemTrait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemTrait {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("unsafety", &self.unsafety);
                formatter.field("auto_token", &self.auto_token);
                formatter.field("restriction", &self.restriction);
                formatter.field("trait_token", &self.trait_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("supertraits", &self.supertraits);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("items", &self.items);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemTrait")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemTraitAlias {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemTraitAlias {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("trait_token", &self.trait_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("bounds", &self.bounds);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemTraitAlias")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemType {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("type_token", &self.type_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("ty", &self.ty);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemType")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemUnion {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemUnion {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("union_token", &self.union_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("fields", &self.fields);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemUnion")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ItemUse {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ItemUse {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("vis", &self.vis);
                formatter.field("use_token", &self.use_token);
                formatter.field("leading_colon", &self.leading_colon);
                formatter.field("tree", &self.tree);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "ItemUse")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Label {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Label");
        formatter.field("name", &self.name);
        formatter.field("colon_token", &self.colon_token);
        formatter.finish()
    }
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Lifetime {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl Lifetime {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("apostrophe", &self.apostrophe);
                formatter.field("ident", &self.ident);
                formatter.finish()
            }
        }
        self.debug(formatter, "Lifetime")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for LifetimeParam {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("LifetimeParam");
        formatter.field("attrs", &self.attrs);
        formatter.field("lifetime", &self.lifetime);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Lit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Lit::")?;
        match self {
            Lit::Str(v0) => v0.debug(formatter, "Str"),
            Lit::ByteStr(v0) => v0.debug(formatter, "ByteStr"),
            Lit::Byte(v0) => v0.debug(formatter, "Byte"),
            Lit::Char(v0) => v0.debug(formatter, "Char"),
            Lit::Int(v0) => v0.debug(formatter, "Int"),
            Lit::Float(v0) => v0.debug(formatter, "Float"),
            Lit::Bool(v0) => v0.debug(formatter, "Bool"),
            Lit::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Local {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl Local {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("let_token", &self.let_token);
                formatter.field("pat", &self.pat);
                formatter.field("init", &self.init);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "Local")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for LocalInit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("LocalInit");
        formatter.field("eq_token", &self.eq_token);
        formatter.field("expr", &self.expr);
        formatter.field("diverge", &self.diverge);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Macro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Macro");
        formatter.field("path", &self.path);
        formatter.field("bang_token", &self.bang_token);
        formatter.field("delimiter", &self.delimiter);
        formatter.field("tokens", &self.tokens);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for MacroDelimiter {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("MacroDelimiter::")?;
        match self {
            MacroDelimiter::Paren(v0) => {
                let mut formatter = formatter.debug_tuple("Paren");
                formatter.field(v0);
                formatter.finish()
            }
            MacroDelimiter::Brace(v0) => {
                let mut formatter = formatter.debug_tuple("Brace");
                formatter.field(v0);
                formatter.finish()
            }
            MacroDelimiter::Bracket(v0) => {
                let mut formatter = formatter.debug_tuple("Bracket");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Member {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Member::")?;
        match self {
            Member::Named(v0) => {
                let mut formatter = formatter.debug_tuple("Named");
                formatter.field(v0);
                formatter.finish()
            }
            Member::Unnamed(v0) => {
                let mut formatter = formatter.debug_tuple("Unnamed");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Meta {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Meta::")?;
        match self {
            Meta::Path(v0) => v0.debug(formatter, "Path"),
            Meta::List(v0) => v0.debug(formatter, "List"),
            Meta::NameValue(v0) => v0.debug(formatter, "NameValue"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for MetaList {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl MetaList {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("path", &self.path);
                formatter.field("delimiter", &self.delimiter);
                formatter.field("tokens", &self.tokens);
                formatter.finish()
            }
        }
        self.debug(formatter, "MetaList")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for MetaNameValue {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl MetaNameValue {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("path", &self.path);
                formatter.field("eq_token", &self.eq_token);
                formatter.field("value", &self.value);
                formatter.finish()
            }
        }
        self.debug(formatter, "MetaNameValue")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ParenthesizedGenericArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl ParenthesizedGenericArguments {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("inputs", &self.inputs);
                formatter.field("output", &self.output);
                formatter.finish()
            }
        }
        self.debug(formatter, "ParenthesizedGenericArguments")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Pat {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Pat::")?;
        match self {
            Pat::Const(v0) => v0.debug(formatter, "Const"),
            Pat::Ident(v0) => v0.debug(formatter, "Ident"),
            Pat::Lit(v0) => v0.debug(formatter, "Lit"),
            Pat::Macro(v0) => v0.debug(formatter, "Macro"),
            Pat::Or(v0) => v0.debug(formatter, "Or"),
            Pat::Paren(v0) => v0.debug(formatter, "Paren"),
            Pat::Path(v0) => v0.debug(formatter, "Path"),
            Pat::Range(v0) => v0.debug(formatter, "Range"),
            Pat::Reference(v0) => v0.debug(formatter, "Reference"),
            Pat::Rest(v0) => v0.debug(formatter, "Rest"),
            Pat::Slice(v0) => v0.debug(formatter, "Slice"),
            Pat::Struct(v0) => v0.debug(formatter, "Struct"),
            Pat::Tuple(v0) => v0.debug(formatter, "Tuple"),
            Pat::TupleStruct(v0) => v0.debug(formatter, "TupleStruct"),
            Pat::Type(v0) => v0.debug(formatter, "Type"),
            Pat::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Wild(v0) => v0.debug(formatter, "Wild"),
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatIdent {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatIdent {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("by_ref", &self.by_ref);
                formatter.field("mutability", &self.mutability);
                formatter.field("ident", &self.ident);
                formatter.field("subpat", &self.subpat);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatIdent")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatOr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatOr {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("leading_vert", &self.leading_vert);
                formatter.field("cases", &self.cases);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatOr")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatParen {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatParen {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("pat", &self.pat);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatParen")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatReference {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("and_token", &self.and_token);
                formatter.field("mutability", &self.mutability);
                formatter.field("pat", &self.pat);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatReference")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatRest {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatRest {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("dot2_token", &self.dot2_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatRest")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatSlice {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatSlice {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatSlice")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatStruct {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("qself", &self.qself);
                formatter.field("path", &self.path);
                formatter.field("brace_token", &self.brace_token);
                formatter.field("fields", &self.fields);
                formatter.field("rest", &self.rest);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatStruct")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatTuple {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatTuple")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatTupleStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatTupleStruct {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("qself", &self.qself);
                formatter.field("path", &self.path);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatTupleStruct")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatType {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("pat", &self.pat);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatType")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PatWild {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl PatWild {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("underscore_token", &self.underscore_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "PatWild")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Path {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl Path {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("leading_colon", &self.leading_colon);
                formatter.field("segments", &self.segments);
                formatter.finish()
            }
        }
        self.debug(formatter, "Path")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PathArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("PathArguments::")?;
        match self {
            PathArguments::None => formatter.write_str("None"),
            PathArguments::AngleBracketed(v0) => v0.debug(formatter, "AngleBracketed"),
            PathArguments::Parenthesized(v0) => v0.debug(formatter, "Parenthesized"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PathSegment {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PathSegment");
        formatter.field("ident", &self.ident);
        formatter.field("arguments", &self.arguments);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PredicateLifetime {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PredicateLifetime");
        formatter.field("lifetime", &self.lifetime);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for PredicateType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PredicateType");
        formatter.field("lifetimes", &self.lifetimes);
        formatter.field("bounded_ty", &self.bounded_ty);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for QSelf {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("QSelf");
        formatter.field("lt_token", &self.lt_token);
        formatter.field("ty", &self.ty);
        formatter.field("position", &self.position);
        formatter.field("as_token", &self.as_token);
        formatter.field("gt_token", &self.gt_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for RangeLimits {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("RangeLimits::")?;
        match self {
            RangeLimits::HalfOpen(v0) => {
                let mut formatter = formatter.debug_tuple("HalfOpen");
                formatter.field(v0);
                formatter.finish()
            }
            RangeLimits::Closed(v0) => {
                let mut formatter = formatter.debug_tuple("Closed");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Receiver {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Receiver");
        formatter.field("attrs", &self.attrs);
        formatter.field("reference", &self.reference);
        formatter.field("mutability", &self.mutability);
        formatter.field("self_token", &self.self_token);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for ReturnType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("ReturnType::")?;
        match self {
            ReturnType::Default => formatter.write_str("Default"),
            ReturnType::Type(v0, v1) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.field(v1);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Signature {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Signature");
        formatter.field("constness", &self.constness);
        formatter.field("asyncness", &self.asyncness);
        formatter.field("unsafety", &self.unsafety);
        formatter.field("abi", &self.abi);
        formatter.field("fn_token", &self.fn_token);
        formatter.field("ident", &self.ident);
        formatter.field("generics", &self.generics);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("inputs", &self.inputs);
        formatter.field("variadic", &self.variadic);
        formatter.field("output", &self.output);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for StaticMutability {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("StaticMutability::")?;
        match self {
            StaticMutability::Mut(v0) => {
                let mut formatter = formatter.debug_tuple("Mut");
                formatter.field(v0);
                formatter.finish()
            }
            StaticMutability::None => formatter.write_str("None"),
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Stmt {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Stmt::")?;
        match self {
            Stmt::Local(v0) => v0.debug(formatter, "Local"),
            Stmt::Item(v0) => {
                let mut formatter = formatter.debug_tuple("Item");
                formatter.field(v0);
                formatter.finish()
            }
            Stmt::Expr(v0, v1) => {
                let mut formatter = formatter.debug_tuple("Expr");
                formatter.field(v0);
                formatter.field(v1);
                formatter.finish()
            }
            Stmt::Macro(v0) => v0.debug(formatter, "Macro"),
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for StmtMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl StmtMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("mac", &self.mac);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "StmtMacro")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitBound {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TraitBound");
        formatter.field("paren_token", &self.paren_token);
        formatter.field("modifier", &self.modifier);
        formatter.field("lifetimes", &self.lifetimes);
        formatter.field("path", &self.path);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitBoundModifier {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("TraitBoundModifier::")?;
        match self {
            TraitBoundModifier::None => formatter.write_str("None"),
            TraitBoundModifier::Maybe(v0) => {
                let mut formatter = formatter.debug_tuple("Maybe");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("TraitItem::")?;
        match self {
            TraitItem::Const(v0) => v0.debug(formatter, "Const"),
            TraitItem::Fn(v0) => v0.debug(formatter, "Fn"),
            TraitItem::Type(v0) => v0.debug(formatter, "Type"),
            TraitItem::Macro(v0) => v0.debug(formatter, "Macro"),
            TraitItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TraitItemConst {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("const_token", &self.const_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("ty", &self.ty);
                formatter.field("default", &self.default);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TraitItemConst")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TraitItemFn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("sig", &self.sig);
                formatter.field("default", &self.default);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TraitItemFn")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TraitItemMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("mac", &self.mac);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TraitItemMacro")
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TraitItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TraitItemType {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("attrs", &self.attrs);
                formatter.field("type_token", &self.type_token);
                formatter.field("ident", &self.ident);
                formatter.field("generics", &self.generics);
                formatter.field("colon_token", &self.colon_token);
                formatter.field("bounds", &self.bounds);
                formatter.field("default", &self.default);
                formatter.field("semi_token", &self.semi_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TraitItemType")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Type {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Type::")?;
        match self {
            Type::Array(v0) => v0.debug(formatter, "Array"),
            Type::BareFn(v0) => v0.debug(formatter, "BareFn"),
            Type::Group(v0) => v0.debug(formatter, "Group"),
            Type::ImplTrait(v0) => v0.debug(formatter, "ImplTrait"),
            Type::Infer(v0) => v0.debug(formatter, "Infer"),
            Type::Macro(v0) => v0.debug(formatter, "Macro"),
            Type::Never(v0) => v0.debug(formatter, "Never"),
            Type::Paren(v0) => v0.debug(formatter, "Paren"),
            Type::Path(v0) => v0.debug(formatter, "Path"),
            Type::Ptr(v0) => v0.debug(formatter, "Ptr"),
            Type::Reference(v0) => v0.debug(formatter, "Reference"),
            Type::Slice(v0) => v0.debug(formatter, "Slice"),
            Type::TraitObject(v0) => v0.debug(formatter, "TraitObject"),
            Type::Tuple(v0) => v0.debug(formatter, "Tuple"),
            Type::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeArray {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeArray {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("elem", &self.elem);
                formatter.field("semi_token", &self.semi_token);
                formatter.field("len", &self.len);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeArray")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeBareFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeBareFn {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("lifetimes", &self.lifetimes);
                formatter.field("unsafety", &self.unsafety);
                formatter.field("abi", &self.abi);
                formatter.field("fn_token", &self.fn_token);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("inputs", &self.inputs);
                formatter.field("variadic", &self.variadic);
                formatter.field("output", &self.output);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeBareFn")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeGroup {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeGroup {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("group_token", &self.group_token);
                formatter.field("elem", &self.elem);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeGroup")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeImplTrait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeImplTrait {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("impl_token", &self.impl_token);
                formatter.field("bounds", &self.bounds);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeImplTrait")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeInfer {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeInfer {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("underscore_token", &self.underscore_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeInfer")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeMacro {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("mac", &self.mac);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeMacro")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeNever {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeNever {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("bang_token", &self.bang_token);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeNever")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeParam {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeParam");
        formatter.field("attrs", &self.attrs);
        formatter.field("ident", &self.ident);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("default", &self.default);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeParamBound {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("TypeParamBound::")?;
        match self {
            TypeParamBound::Trait(v0) => {
                let mut formatter = formatter.debug_tuple("Trait");
                formatter.field(v0);
                formatter.finish()
            }
            TypeParamBound::Lifetime(v0) => v0.debug(formatter, "Lifetime"),
            TypeParamBound::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeParen {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeParen {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("elem", &self.elem);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeParen")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypePath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypePath {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("qself", &self.qself);
                formatter.field("path", &self.path);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypePath")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypePtr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypePtr {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("star_token", &self.star_token);
                formatter.field("const_token", &self.const_token);
                formatter.field("mutability", &self.mutability);
                formatter.field("elem", &self.elem);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypePtr")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeReference {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("and_token", &self.and_token);
                formatter.field("lifetime", &self.lifetime);
                formatter.field("mutability", &self.mutability);
                formatter.field("elem", &self.elem);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeReference")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeSlice {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeSlice {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("bracket_token", &self.bracket_token);
                formatter.field("elem", &self.elem);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeSlice")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeTraitObject {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeTraitObject {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("dyn_token", &self.dyn_token);
                formatter.field("bounds", &self.bounds);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeTraitObject")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for TypeTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl TypeTuple {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("elems", &self.elems);
                formatter.finish()
            }
        }
        self.debug(formatter, "TypeTuple")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UnOp {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("UnOp::")?;
        match self {
            UnOp::Deref(v0) => {
                let mut formatter = formatter.debug_tuple("Deref");
                formatter.field(v0);
                formatter.finish()
            }
            UnOp::Not(v0) => {
                let mut formatter = formatter.debug_tuple("Not");
                formatter.field(v0);
                formatter.finish()
            }
            UnOp::Neg(v0) => {
                let mut formatter = formatter.debug_tuple("Neg");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UseGlob {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("UseGlob");
        formatter.field("star_token", &self.star_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UseGroup {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("UseGroup");
        formatter.field("brace_token", &self.brace_token);
        formatter.field("items", &self.items);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UseName {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("UseName");
        formatter.field("ident", &self.ident);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UsePath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("UsePath");
        formatter.field("ident", &self.ident);
        formatter.field("colon2_token", &self.colon2_token);
        formatter.field("tree", &self.tree);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UseRename {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("UseRename");
        formatter.field("ident", &self.ident);
        formatter.field("as_token", &self.as_token);
        formatter.field("rename", &self.rename);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for UseTree {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("UseTree::")?;
        match self {
            UseTree::Path(v0) => {
                let mut formatter = formatter.debug_tuple("Path");
                formatter.field(v0);
                formatter.finish()
            }
            UseTree::Name(v0) => {
                let mut formatter = formatter.debug_tuple("Name");
                formatter.field(v0);
                formatter.finish()
            }
            UseTree::Rename(v0) => {
                let mut formatter = formatter.debug_tuple("Rename");
                formatter.field(v0);
                formatter.finish()
            }
            UseTree::Glob(v0) => {
                let mut formatter = formatter.debug_tuple("Glob");
                formatter.field(v0);
                formatter.finish()
            }
            UseTree::Group(v0) => {
                let mut formatter = formatter.debug_tuple("Group");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Variadic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Variadic");
        formatter.field("attrs", &self.attrs);
        formatter.field("pat", &self.pat);
        formatter.field("dots", &self.dots);
        formatter.field("comma", &self.comma);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Variant {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Variant");
        formatter.field("attrs", &self.attrs);
        formatter.field("ident", &self.ident);
        formatter.field("fields", &self.fields);
        formatter.field("discriminant", &self.discriminant);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for VisRestricted {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        impl VisRestricted {
            fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
                let mut formatter = formatter.debug_struct(name);
                formatter.field("pub_token", &self.pub_token);
                formatter.field("paren_token", &self.paren_token);
                formatter.field("in_token", &self.in_token);
                formatter.field("path", &self.path);
                formatter.finish()
            }
        }
        self.debug(formatter, "VisRestricted")
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for Visibility {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Visibility::")?;
        match self {
            Visibility::Public(v0) => {
                let mut formatter = formatter.debug_tuple("Public");
                formatter.field(v0);
                formatter.finish()
            }
            Visibility::Restricted(v0) => v0.debug(formatter, "Restricted"),
            Visibility::Inherited => formatter.write_str("Inherited"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for WhereClause {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("WhereClause");
        formatter.field("where_token", &self.where_token);
        formatter.field("predicates", &self.predicates);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
impl Debug for WherePredicate {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("WherePredicate::")?;
        match self {
            WherePredicate::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                formatter.field(v0);
                formatter.finish()
            }
            WherePredicate::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}