New upstream version 1.48.0~beta.8+dfsg1

[rustc.git] / vendor / 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"))]
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"))]
impl Debug for AngleBracketedGenericArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
        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()
    }
}
#[cfg(feature = "full")]
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"))]
impl Debug for AttrStyle {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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"))]
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("path", &self.path);
        formatter.field("tokens", &self.tokens);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for BinOp {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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::AddEq(v0) => {
                let mut formatter = formatter.debug_tuple("AddEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::SubEq(v0) => {
                let mut formatter = formatter.debug_tuple("SubEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::MulEq(v0) => {
                let mut formatter = formatter.debug_tuple("MulEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::DivEq(v0) => {
                let mut formatter = formatter.debug_tuple("DivEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::RemEq(v0) => {
                let mut formatter = formatter.debug_tuple("RemEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitXorEq(v0) => {
                let mut formatter = formatter.debug_tuple("BitXorEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitAndEq(v0) => {
                let mut formatter = formatter.debug_tuple("BitAndEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::BitOrEq(v0) => {
                let mut formatter = formatter.debug_tuple("BitOrEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::ShlEq(v0) => {
                let mut formatter = formatter.debug_tuple("ShlEq");
                formatter.field(v0);
                formatter.finish()
            }
            BinOp::ShrEq(v0) => {
                let mut formatter = formatter.debug_tuple("ShrEq");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for Binding {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Binding");
        formatter.field("ident", &self.ident);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
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"))]
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"))]
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"))]
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("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(feature = "derive")]
impl Debug for Data {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Data::Struct(v0) => {
                let mut formatter = formatter.debug_tuple("Struct");
                formatter.field(v0);
                formatter.finish()
            }
            Data::Enum(v0) => {
                let mut formatter = formatter.debug_tuple("Enum");
                formatter.field(v0);
                formatter.finish()
            }
            Data::Union(v0) => {
                let mut formatter = formatter.debug_tuple("Union");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "derive")]
impl Debug for DataEnum {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("DataEnum");
        formatter.field("enum_token", &self.enum_token);
        formatter.field("brace_token", &self.brace_token);
        formatter.field("variants", &self.variants);
        formatter.finish()
    }
}
#[cfg(feature = "derive")]
impl Debug for DataStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("DataStruct");
        formatter.field("struct_token", &self.struct_token);
        formatter.field("fields", &self.fields);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "derive")]
impl Debug for DataUnion {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("DataUnion");
        formatter.field("union_token", &self.union_token);
        formatter.field("fields", &self.fields);
        formatter.finish()
    }
}
#[cfg(feature = "derive")]
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"))]
impl Debug for Expr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            #[cfg(feature = "full")]
            Expr::Array(v0) => {
                let mut formatter = formatter.debug_tuple("Array");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Assign(v0) => {
                let mut formatter = formatter.debug_tuple("Assign");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::AssignOp(v0) => {
                let mut formatter = formatter.debug_tuple("AssignOp");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Async(v0) => {
                let mut formatter = formatter.debug_tuple("Async");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Await(v0) => {
                let mut formatter = formatter.debug_tuple("Await");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Binary(v0) => {
                let mut formatter = formatter.debug_tuple("Binary");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Block(v0) => {
                let mut formatter = formatter.debug_tuple("Block");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Box(v0) => {
                let mut formatter = formatter.debug_tuple("Box");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Break(v0) => {
                let mut formatter = formatter.debug_tuple("Break");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Call(v0) => {
                let mut formatter = formatter.debug_tuple("Call");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Cast(v0) => {
                let mut formatter = formatter.debug_tuple("Cast");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Closure(v0) => {
                let mut formatter = formatter.debug_tuple("Closure");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Continue(v0) => {
                let mut formatter = formatter.debug_tuple("Continue");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Field(v0) => {
                let mut formatter = formatter.debug_tuple("Field");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::ForLoop(v0) => {
                let mut formatter = formatter.debug_tuple("ForLoop");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Group(v0) => {
                let mut formatter = formatter.debug_tuple("Group");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::If(v0) => {
                let mut formatter = formatter.debug_tuple("If");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Index(v0) => {
                let mut formatter = formatter.debug_tuple("Index");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Let(v0) => {
                let mut formatter = formatter.debug_tuple("Let");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Lit(v0) => {
                let mut formatter = formatter.debug_tuple("Lit");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Loop(v0) => {
                let mut formatter = formatter.debug_tuple("Loop");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Match(v0) => {
                let mut formatter = formatter.debug_tuple("Match");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::MethodCall(v0) => {
                let mut formatter = formatter.debug_tuple("MethodCall");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Paren(v0) => {
                let mut formatter = formatter.debug_tuple("Paren");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Path(v0) => {
                let mut formatter = formatter.debug_tuple("Path");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Range(v0) => {
                let mut formatter = formatter.debug_tuple("Range");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Reference(v0) => {
                let mut formatter = formatter.debug_tuple("Reference");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Repeat(v0) => {
                let mut formatter = formatter.debug_tuple("Repeat");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Return(v0) => {
                let mut formatter = formatter.debug_tuple("Return");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Struct(v0) => {
                let mut formatter = formatter.debug_tuple("Struct");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Try(v0) => {
                let mut formatter = formatter.debug_tuple("Try");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::TryBlock(v0) => {
                let mut formatter = formatter.debug_tuple("TryBlock");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Tuple(v0) => {
                let mut formatter = formatter.debug_tuple("Tuple");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Unary(v0) => {
                let mut formatter = formatter.debug_tuple("Unary");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Unsafe(v0) => {
                let mut formatter = formatter.debug_tuple("Unsafe");
                formatter.field(v0);
                formatter.finish()
            }
            Expr::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::While(v0) => {
                let mut formatter = formatter.debug_tuple("While");
                formatter.field(v0);
                formatter.finish()
            }
            #[cfg(feature = "full")]
            Expr::Yield(v0) => {
                let mut formatter = formatter.debug_tuple("Yield");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for ExprArray {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprArray");
        formatter.field("attrs", &self.attrs);
        formatter.field("bracket_token", &self.bracket_token);
        formatter.field("elems", &self.elems);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprAssign {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprAssign");
        formatter.field("attrs", &self.attrs);
        formatter.field("left", &self.left);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("right", &self.right);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprAssignOp {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprAssignOp");
        formatter.field("attrs", &self.attrs);
        formatter.field("left", &self.left);
        formatter.field("op", &self.op);
        formatter.field("right", &self.right);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprAsync {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprAsync");
        formatter.field("attrs", &self.attrs);
        formatter.field("async_token", &self.async_token);
        formatter.field("capture", &self.capture);
        formatter.field("block", &self.block);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprAwait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprAwait");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprBinary {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprBinary");
        formatter.field("attrs", &self.attrs);
        formatter.field("left", &self.left);
        formatter.field("op", &self.op);
        formatter.field("right", &self.right);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprBlock {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprBlock");
        formatter.field("attrs", &self.attrs);
        formatter.field("label", &self.label);
        formatter.field("block", &self.block);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprBox {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprBox");
        formatter.field("attrs", &self.attrs);
        formatter.field("box_token", &self.box_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprBreak {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprBreak");
        formatter.field("attrs", &self.attrs);
        formatter.field("break_token", &self.break_token);
        formatter.field("label", &self.label);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprCall {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprCall");
        formatter.field("attrs", &self.attrs);
        formatter.field("func", &self.func);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("args", &self.args);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprCast {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprCast");
        formatter.field("attrs", &self.attrs);
        formatter.field("expr", &self.expr);
        formatter.field("as_token", &self.as_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprClosure {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprClosure");
        formatter.field("attrs", &self.attrs);
        formatter.field("asyncness", &self.asyncness);
        formatter.field("movability", &self.movability);
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprContinue {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprContinue");
        formatter.field("attrs", &self.attrs);
        formatter.field("continue_token", &self.continue_token);
        formatter.field("label", &self.label);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprField {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprField");
        formatter.field("attrs", &self.attrs);
        formatter.field("base", &self.base);
        formatter.field("dot_token", &self.dot_token);
        formatter.field("member", &self.member);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprForLoop {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprForLoop");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprGroup {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprGroup");
        formatter.field("attrs", &self.attrs);
        formatter.field("group_token", &self.group_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprIf {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprIf");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprIndex {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprIndex");
        formatter.field("attrs", &self.attrs);
        formatter.field("expr", &self.expr);
        formatter.field("bracket_token", &self.bracket_token);
        formatter.field("index", &self.index);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprLet {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprLet");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprLit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprLit");
        formatter.field("attrs", &self.attrs);
        formatter.field("lit", &self.lit);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprLoop {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprLoop");
        formatter.field("attrs", &self.attrs);
        formatter.field("label", &self.label);
        formatter.field("loop_token", &self.loop_token);
        formatter.field("body", &self.body);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("mac", &self.mac);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprMatch {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprMatch");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprMethodCall {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprMethodCall");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprParen {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprParen");
        formatter.field("attrs", &self.attrs);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprPath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprPath");
        formatter.field("attrs", &self.attrs);
        formatter.field("qself", &self.qself);
        formatter.field("path", &self.path);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprRange {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprRange");
        formatter.field("attrs", &self.attrs);
        formatter.field("from", &self.from);
        formatter.field("limits", &self.limits);
        formatter.field("to", &self.to);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprReference");
        formatter.field("attrs", &self.attrs);
        formatter.field("and_token", &self.and_token);
        formatter.field("raw", &self.raw);
        formatter.field("mutability", &self.mutability);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprRepeat {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprRepeat");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprReturn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprReturn");
        formatter.field("attrs", &self.attrs);
        formatter.field("return_token", &self.return_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprStruct");
        formatter.field("attrs", &self.attrs);
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprTry {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprTry");
        formatter.field("attrs", &self.attrs);
        formatter.field("expr", &self.expr);
        formatter.field("question_token", &self.question_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprTryBlock {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprTryBlock");
        formatter.field("attrs", &self.attrs);
        formatter.field("try_token", &self.try_token);
        formatter.field("block", &self.block);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprTuple");
        formatter.field("attrs", &self.attrs);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("elems", &self.elems);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprType");
        formatter.field("attrs", &self.attrs);
        formatter.field("expr", &self.expr);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ExprUnary {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprUnary");
        formatter.field("attrs", &self.attrs);
        formatter.field("op", &self.op);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprUnsafe {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprUnsafe");
        formatter.field("attrs", &self.attrs);
        formatter.field("unsafe_token", &self.unsafe_token);
        formatter.field("block", &self.block);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprWhile {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprWhile");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ExprYield {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ExprYield");
        formatter.field("attrs", &self.attrs);
        formatter.field("yield_token", &self.yield_token);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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("ident", &self.ident);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
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(feature = "full")]
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"))]
impl Debug for Fields {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Fields::Named(v0) => {
                let mut formatter = formatter.debug_tuple("Named");
                formatter.field(v0);
                formatter.finish()
            }
            Fields::Unnamed(v0) => {
                let mut formatter = formatter.debug_tuple("Unnamed");
                formatter.field(v0);
                formatter.finish()
            }
            Fields::Unit => formatter.write_str("Unit"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for FieldsNamed {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("FieldsNamed");
        formatter.field("brace_token", &self.brace_token);
        formatter.field("named", &self.named);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for FieldsUnnamed {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("FieldsUnnamed");
        formatter.field("paren_token", &self.paren_token);
        formatter.field("unnamed", &self.unnamed);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
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")]
impl Debug for FnArg {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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")]
impl Debug for ForeignItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ForeignItem::Fn(v0) => {
                let mut formatter = formatter.debug_tuple("Fn");
                formatter.field(v0);
                formatter.finish()
            }
            ForeignItem::Static(v0) => {
                let mut formatter = formatter.debug_tuple("Static");
                formatter.field(v0);
                formatter.finish()
            }
            ForeignItem::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            ForeignItem::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            ForeignItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for ForeignItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ForeignItemFn");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("sig", &self.sig);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ForeignItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ForeignItemMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("mac", &self.mac);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ForeignItemStatic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ForeignItemStatic");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ForeignItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ForeignItemType");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("type_token", &self.type_token);
        formatter.field("ident", &self.ident);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for GenericArgument {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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::Binding(v0) => {
                let mut formatter = formatter.debug_tuple("Binding");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::Constraint(v0) => {
                let mut formatter = formatter.debug_tuple("Constraint");
                formatter.field(v0);
                formatter.finish()
            }
            GenericArgument::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
impl Debug for GenericMethodArgument {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            GenericMethodArgument::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            GenericMethodArgument::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for GenericParam {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            GenericParam::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            GenericParam::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                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"))]
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")]
impl Debug for ImplItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ImplItem::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
            ImplItem::Method(v0) => {
                let mut formatter = formatter.debug_tuple("Method");
                formatter.field(v0);
                formatter.finish()
            }
            ImplItem::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            ImplItem::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            ImplItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for ImplItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ImplItemConst");
        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("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()
    }
}
#[cfg(feature = "full")]
impl Debug for ImplItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ImplItemMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("mac", &self.mac);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ImplItemMethod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ImplItemMethod");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ImplItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ImplItemType");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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")]
impl Debug for Item {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Item::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Enum(v0) => {
                let mut formatter = formatter.debug_tuple("Enum");
                formatter.field(v0);
                formatter.finish()
            }
            Item::ExternCrate(v0) => {
                let mut formatter = formatter.debug_tuple("ExternCrate");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Fn(v0) => {
                let mut formatter = formatter.debug_tuple("Fn");
                formatter.field(v0);
                formatter.finish()
            }
            Item::ForeignMod(v0) => {
                let mut formatter = formatter.debug_tuple("ForeignMod");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Impl(v0) => {
                let mut formatter = formatter.debug_tuple("Impl");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Macro2(v0) => {
                let mut formatter = formatter.debug_tuple("Macro2");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Mod(v0) => {
                let mut formatter = formatter.debug_tuple("Mod");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Static(v0) => {
                let mut formatter = formatter.debug_tuple("Static");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Struct(v0) => {
                let mut formatter = formatter.debug_tuple("Struct");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Trait(v0) => {
                let mut formatter = formatter.debug_tuple("Trait");
                formatter.field(v0);
                formatter.finish()
            }
            Item::TraitAlias(v0) => {
                let mut formatter = formatter.debug_tuple("TraitAlias");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Union(v0) => {
                let mut formatter = formatter.debug_tuple("Union");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Use(v0) => {
                let mut formatter = formatter.debug_tuple("Use");
                formatter.field(v0);
                formatter.finish()
            }
            Item::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for ItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemConst");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        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("expr", &self.expr);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemEnum {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemEnum");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemExternCrate {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemExternCrate");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemFn");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("sig", &self.sig);
        formatter.field("block", &self.block);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemForeignMod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemForeignMod");
        formatter.field("attrs", &self.attrs);
        formatter.field("abi", &self.abi);
        formatter.field("brace_token", &self.brace_token);
        formatter.field("items", &self.items);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemImpl {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemImpl");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("ident", &self.ident);
        formatter.field("mac", &self.mac);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemMacro2 {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemMacro2");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("macro_token", &self.macro_token);
        formatter.field("ident", &self.ident);
        formatter.field("rules", &self.rules);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemMod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemMod");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("mod_token", &self.mod_token);
        formatter.field("ident", &self.ident);
        formatter.field("content", &self.content);
        formatter.field("semi", &self.semi);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemStatic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemStatic");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemStruct");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemTrait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemTrait");
        formatter.field("attrs", &self.attrs);
        formatter.field("vis", &self.vis);
        formatter.field("unsafety", &self.unsafety);
        formatter.field("auto_token", &self.auto_token);
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemTraitAlias {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemTraitAlias");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemType");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemUnion {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemUnion");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for ItemUse {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ItemUse");
        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()
    }
}
#[cfg(feature = "full")]
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()
    }
}
impl Debug for Lifetime {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Lifetime");
        formatter.field("apostrophe", &self.apostrophe);
        formatter.field("ident", &self.ident);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for LifetimeDef {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("LifetimeDef");
        formatter.field("attrs", &self.attrs);
        formatter.field("lifetime", &self.lifetime);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
impl Debug for Lit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Lit::Str(v0) => {
                let mut formatter = formatter.debug_tuple("Str");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::ByteStr(v0) => {
                let mut formatter = formatter.debug_tuple("ByteStr");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Byte(v0) => {
                let mut formatter = formatter.debug_tuple("Byte");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Char(v0) => {
                let mut formatter = formatter.debug_tuple("Char");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Int(v0) => {
                let mut formatter = formatter.debug_tuple("Int");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Float(v0) => {
                let mut formatter = formatter.debug_tuple("Float");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Bool(v0) => {
                let mut formatter = formatter.debug_tuple("Bool");
                formatter.field(v0);
                formatter.finish()
            }
            Lit::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(feature = "full")]
impl Debug for Local {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Local");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for MacroDelimiter {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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"))]
impl Debug for Member {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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"))]
impl Debug for Meta {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Meta::Path(v0) => {
                let mut formatter = formatter.debug_tuple("Path");
                formatter.field(v0);
                formatter.finish()
            }
            Meta::List(v0) => {
                let mut formatter = formatter.debug_tuple("List");
                formatter.field(v0);
                formatter.finish()
            }
            Meta::NameValue(v0) => {
                let mut formatter = formatter.debug_tuple("NameValue");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for MetaList {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("MetaList");
        formatter.field("path", &self.path);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("nested", &self.nested);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for MetaNameValue {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("MetaNameValue");
        formatter.field("path", &self.path);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("lit", &self.lit);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for MethodTurbofish {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("MethodTurbofish");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for NestedMeta {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            NestedMeta::Meta(v0) => {
                let mut formatter = formatter.debug_tuple("Meta");
                formatter.field(v0);
                formatter.finish()
            }
            NestedMeta::Lit(v0) => {
                let mut formatter = formatter.debug_tuple("Lit");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ParenthesizedGenericArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
        formatter.field("paren_token", &self.paren_token);
        formatter.field("inputs", &self.inputs);
        formatter.field("output", &self.output);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for Pat {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Pat::Box(v0) => {
                let mut formatter = formatter.debug_tuple("Box");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Ident(v0) => {
                let mut formatter = formatter.debug_tuple("Ident");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Lit(v0) => {
                let mut formatter = formatter.debug_tuple("Lit");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Or(v0) => {
                let mut formatter = formatter.debug_tuple("Or");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Path(v0) => {
                let mut formatter = formatter.debug_tuple("Path");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Range(v0) => {
                let mut formatter = formatter.debug_tuple("Range");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Reference(v0) => {
                let mut formatter = formatter.debug_tuple("Reference");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Rest(v0) => {
                let mut formatter = formatter.debug_tuple("Rest");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Slice(v0) => {
                let mut formatter = formatter.debug_tuple("Slice");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Struct(v0) => {
                let mut formatter = formatter.debug_tuple("Struct");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Tuple(v0) => {
                let mut formatter = formatter.debug_tuple("Tuple");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::TupleStruct(v0) => {
                let mut formatter = formatter.debug_tuple("TupleStruct");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            Pat::Wild(v0) => {
                let mut formatter = formatter.debug_tuple("Wild");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for PatBox {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatBox");
        formatter.field("attrs", &self.attrs);
        formatter.field("box_token", &self.box_token);
        formatter.field("pat", &self.pat);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatIdent {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatIdent");
        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()
    }
}
#[cfg(feature = "full")]
impl Debug for PatLit {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatLit");
        formatter.field("attrs", &self.attrs);
        formatter.field("expr", &self.expr);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("mac", &self.mac);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatOr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatOr");
        formatter.field("attrs", &self.attrs);
        formatter.field("leading_vert", &self.leading_vert);
        formatter.field("cases", &self.cases);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatPath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatPath");
        formatter.field("attrs", &self.attrs);
        formatter.field("qself", &self.qself);
        formatter.field("path", &self.path);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatRange {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatRange");
        formatter.field("attrs", &self.attrs);
        formatter.field("lo", &self.lo);
        formatter.field("limits", &self.limits);
        formatter.field("hi", &self.hi);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatReference");
        formatter.field("attrs", &self.attrs);
        formatter.field("and_token", &self.and_token);
        formatter.field("mutability", &self.mutability);
        formatter.field("pat", &self.pat);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatRest {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatRest");
        formatter.field("attrs", &self.attrs);
        formatter.field("dot2_token", &self.dot2_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatSlice {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatSlice");
        formatter.field("attrs", &self.attrs);
        formatter.field("bracket_token", &self.bracket_token);
        formatter.field("elems", &self.elems);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatStruct");
        formatter.field("attrs", &self.attrs);
        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.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatTuple");
        formatter.field("attrs", &self.attrs);
        formatter.field("paren_token", &self.paren_token);
        formatter.field("elems", &self.elems);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatTupleStruct {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatTupleStruct");
        formatter.field("attrs", &self.attrs);
        formatter.field("path", &self.path);
        formatter.field("pat", &self.pat);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatType");
        formatter.field("attrs", &self.attrs);
        formatter.field("pat", &self.pat);
        formatter.field("colon_token", &self.colon_token);
        formatter.field("ty", &self.ty);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for PatWild {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PatWild");
        formatter.field("attrs", &self.attrs);
        formatter.field("underscore_token", &self.underscore_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for Path {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("Path");
        formatter.field("leading_colon", &self.leading_colon);
        formatter.field("segments", &self.segments);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for PathArguments {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            PathArguments::None => formatter.write_str("None"),
            PathArguments::AngleBracketed(v0) => {
                let mut formatter = formatter.debug_tuple("AngleBracketed");
                formatter.field(v0);
                formatter.finish()
            }
            PathArguments::Parenthesized(v0) => {
                let mut formatter = formatter.debug_tuple("Parenthesized");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for PredicateEq {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("PredicateEq");
        formatter.field("lhs_ty", &self.lhs_ty);
        formatter.field("eq_token", &self.eq_token);
        formatter.field("rhs_ty", &self.rhs_ty);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
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")]
impl Debug for RangeLimits {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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")]
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.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for ReturnType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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")]
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")]
impl Debug for Stmt {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Stmt::Local(v0) => {
                let mut formatter = formatter.debug_tuple("Local");
                formatter.field(v0);
                formatter.finish()
            }
            Stmt::Item(v0) => {
                let mut formatter = formatter.debug_tuple("Item");
                formatter.field(v0);
                formatter.finish()
            }
            Stmt::Expr(v0) => {
                let mut formatter = formatter.debug_tuple("Expr");
                formatter.field(v0);
                formatter.finish()
            }
            Stmt::Semi(v0, v1) => {
                let mut formatter = formatter.debug_tuple("Semi");
                formatter.field(v0);
                formatter.field(v1);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for TraitBoundModifier {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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")]
impl Debug for TraitItem {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            TraitItem::Const(v0) => {
                let mut formatter = formatter.debug_tuple("Const");
                formatter.field(v0);
                formatter.finish()
            }
            TraitItem::Method(v0) => {
                let mut formatter = formatter.debug_tuple("Method");
                formatter.field(v0);
                formatter.finish()
            }
            TraitItem::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            TraitItem::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            TraitItem::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(feature = "full")]
impl Debug for TraitItemConst {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TraitItemConst");
        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("default", &self.default);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for TraitItemMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TraitItemMacro");
        formatter.field("attrs", &self.attrs);
        formatter.field("mac", &self.mac);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for TraitItemMethod {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TraitItemMethod");
        formatter.field("attrs", &self.attrs);
        formatter.field("sig", &self.sig);
        formatter.field("default", &self.default);
        formatter.field("semi_token", &self.semi_token);
        formatter.finish()
    }
}
#[cfg(feature = "full")]
impl Debug for TraitItemType {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TraitItemType");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for Type {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Type::Array(v0) => {
                let mut formatter = formatter.debug_tuple("Array");
                formatter.field(v0);
                formatter.finish()
            }
            Type::BareFn(v0) => {
                let mut formatter = formatter.debug_tuple("BareFn");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Group(v0) => {
                let mut formatter = formatter.debug_tuple("Group");
                formatter.field(v0);
                formatter.finish()
            }
            Type::ImplTrait(v0) => {
                let mut formatter = formatter.debug_tuple("ImplTrait");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Infer(v0) => {
                let mut formatter = formatter.debug_tuple("Infer");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Macro(v0) => {
                let mut formatter = formatter.debug_tuple("Macro");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Never(v0) => {
                let mut formatter = formatter.debug_tuple("Never");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Paren(v0) => {
                let mut formatter = formatter.debug_tuple("Paren");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Path(v0) => {
                let mut formatter = formatter.debug_tuple("Path");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Ptr(v0) => {
                let mut formatter = formatter.debug_tuple("Ptr");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Reference(v0) => {
                let mut formatter = formatter.debug_tuple("Reference");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Slice(v0) => {
                let mut formatter = formatter.debug_tuple("Slice");
                formatter.field(v0);
                formatter.finish()
            }
            Type::TraitObject(v0) => {
                let mut formatter = formatter.debug_tuple("TraitObject");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Tuple(v0) => {
                let mut formatter = formatter.debug_tuple("Tuple");
                formatter.field(v0);
                formatter.finish()
            }
            Type::Verbatim(v0) => {
                let mut formatter = formatter.debug_tuple("Verbatim");
                formatter.field(v0);
                formatter.finish()
            }
            _ => unreachable!(),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeArray {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeArray");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeBareFn {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeBareFn");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeGroup {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeGroup");
        formatter.field("group_token", &self.group_token);
        formatter.field("elem", &self.elem);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeImplTrait {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeImplTrait");
        formatter.field("impl_token", &self.impl_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeInfer {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeInfer");
        formatter.field("underscore_token", &self.underscore_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeMacro {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeMacro");
        formatter.field("mac", &self.mac);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeNever {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeNever");
        formatter.field("bang_token", &self.bang_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for TypeParamBound {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            TypeParamBound::Trait(v0) => {
                let mut formatter = formatter.debug_tuple("Trait");
                formatter.field(v0);
                formatter.finish()
            }
            TypeParamBound::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeParen {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeParen");
        formatter.field("paren_token", &self.paren_token);
        formatter.field("elem", &self.elem);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypePath {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypePath");
        formatter.field("qself", &self.qself);
        formatter.field("path", &self.path);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypePtr {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypePtr");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeReference {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeReference");
        formatter.field("and_token", &self.and_token);
        formatter.field("lifetime", &self.lifetime);
        formatter.field("mutability", &self.mutability);
        formatter.field("elem", &self.elem);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeSlice {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeSlice");
        formatter.field("bracket_token", &self.bracket_token);
        formatter.field("elem", &self.elem);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeTraitObject {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeTraitObject");
        formatter.field("dyn_token", &self.dyn_token);
        formatter.field("bounds", &self.bounds);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for TypeTuple {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("TypeTuple");
        formatter.field("paren_token", &self.paren_token);
        formatter.field("elems", &self.elems);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for UnOp {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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")]
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")]
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")]
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")]
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")]
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")]
impl Debug for UseTree {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        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(any(feature = "derive", feature = "full"))]
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("dots", &self.dots);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for VisCrate {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("VisCrate");
        formatter.field("crate_token", &self.crate_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for VisPublic {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("VisPublic");
        formatter.field("pub_token", &self.pub_token);
        formatter.finish()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for VisRestricted {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        let mut formatter = formatter.debug_struct("VisRestricted");
        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()
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
impl Debug for Visibility {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Visibility::Public(v0) => {
                let mut formatter = formatter.debug_tuple("Public");
                formatter.field(v0);
                formatter.finish()
            }
            Visibility::Crate(v0) => {
                let mut formatter = formatter.debug_tuple("Crate");
                formatter.field(v0);
                formatter.finish()
            }
            Visibility::Restricted(v0) => {
                let mut formatter = formatter.debug_tuple("Restricted");
                formatter.field(v0);
                formatter.finish()
            }
            Visibility::Inherited => formatter.write_str("Inherited"),
        }
    }
}
#[cfg(any(feature = "derive", feature = "full"))]
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"))]
impl Debug for WherePredicate {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        match self {
            WherePredicate::Type(v0) => {
                let mut formatter = formatter.debug_tuple("Type");
                formatter.field(v0);
                formatter.finish()
            }
            WherePredicate::Lifetime(v0) => {
                let mut formatter = formatter.debug_tuple("Lifetime");
                formatter.field(v0);
                formatter.finish()
            }
            WherePredicate::Eq(v0) => {
                let mut formatter = formatter.debug_tuple("Eq");
                formatter.field(v0);
                formatter.finish()
            }
        }
    }
}