| // This file is @generated by syn-internal-codegen. |
| // It is not intended for manual editing. |
| |
| use crate::*; |
| use std::fmt::{self, Debug}; |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Abi { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Abi"); |
| formatter.field("extern_token", &self.extern_token); |
| formatter.field("name", &self.name); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for AngleBracketedGenericArguments { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Arm { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Arm"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("pat", &self.pat); |
| formatter.field("guard", &self.guard); |
| formatter.field("fat_arrow_token", &self.fat_arrow_token); |
| formatter.field("body", &self.body); |
| formatter.field("comma", &self.comma); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Attribute { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Attribute"); |
| formatter.field("pound_token", &self.pound_token); |
| formatter.field("style", &self.style); |
| formatter.field("bracket_token", &self.bracket_token); |
| formatter.field("path", &self.path); |
| formatter.field("tokens", &self.tokens); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for BareFnArg { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("BareFnArg"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("name", &self.name); |
| formatter.field("ty", &self.ty); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Block { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Block"); |
| formatter.field("brace_token", &self.brace_token); |
| formatter.field("stmts", &self.stmts); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for BoundLifetimes { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("BoundLifetimes"); |
| formatter.field("for_token", &self.for_token); |
| formatter.field("lt_token", &self.lt_token); |
| formatter.field("lifetimes", &self.lifetimes); |
| formatter.field("gt_token", &self.gt_token); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ConstParam { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("ConstParam"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("const_token", &self.const_token); |
| formatter.field("ident", &self.ident); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("ty", &self.ty); |
| formatter.field("eq_token", &self.eq_token); |
| formatter.field("default", &self.default); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Constraint { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Constraint"); |
| formatter.field("ident", &self.ident); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("bounds", &self.bounds); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "derive")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Data { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for DeriveInput { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("DeriveInput"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("vis", &self.vis); |
| formatter.field("ident", &self.ident); |
| formatter.field("generics", &self.generics); |
| formatter.field("data", &self.data); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Expr { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| #[cfg(any(syn_no_non_exhaustive, not(feature = "full")))] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ExprArray { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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("movability", &self.movability); |
| formatter.field("asyncness", &self.asyncness); |
| formatter.field("capture", &self.capture); |
| formatter.field("or1_token", &self.or1_token); |
| formatter.field("inputs", &self.inputs); |
| formatter.field("or2_token", &self.or2_token); |
| formatter.field("output", &self.output); |
| formatter.field("body", &self.body); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ExprContinue { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Field { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Field"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("vis", &self.vis); |
| formatter.field("ident", &self.ident); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("ty", &self.ty); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for FieldPat { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("FieldPat"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("member", &self.member); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("pat", &self.pat); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for FieldValue { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("FieldValue"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("member", &self.member); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("expr", &self.expr); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Fields { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for File { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("File"); |
| formatter.field("shebang", &self.shebang); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("items", &self.items); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for FnArg { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| FnArg::Receiver(v0) => { |
| let mut formatter = formatter.debug_tuple("Receiver"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| FnArg::Typed(v0) => { |
| let mut formatter = formatter.debug_tuple("Typed"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ForeignItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ForeignItemFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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::Const(v0) => { |
| let mut formatter = formatter.debug_tuple("Const"); |
| 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() |
| } |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Generics { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Generics"); |
| formatter.field("lt_token", &self.lt_token); |
| formatter.field("params", &self.params); |
| formatter.field("gt_token", &self.gt_token); |
| formatter.field("where_clause", &self.where_clause); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ImplItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ImplItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Index { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Index"); |
| formatter.field("index", &self.index); |
| formatter.field("span", &self.span); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Item { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Label { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Label"); |
| formatter.field("name", &self.name); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.finish() |
| } |
| } |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Lifetime { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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() |
| } |
| } |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Macro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Macro"); |
| formatter.field("path", &self.path); |
| formatter.field("bang_token", &self.bang_token); |
| formatter.field("delimiter", &self.delimiter); |
| formatter.field("tokens", &self.tokens); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for MacroDelimiter { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| MacroDelimiter::Paren(v0) => { |
| let mut formatter = formatter.debug_tuple("Paren"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| MacroDelimiter::Brace(v0) => { |
| let mut formatter = formatter.debug_tuple("Brace"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| MacroDelimiter::Bracket(v0) => { |
| let mut formatter = formatter.debug_tuple("Bracket"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Member { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| Member::Named(v0) => { |
| let mut formatter = formatter.debug_tuple("Named"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| Member::Unnamed(v0) => { |
| let mut formatter = formatter.debug_tuple("Unnamed"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Meta { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for PathSegment { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("PathSegment"); |
| formatter.field("ident", &self.ident); |
| formatter.field("arguments", &self.arguments); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for PredicateLifetime { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("PredicateLifetime"); |
| formatter.field("lifetime", &self.lifetime); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("bounds", &self.bounds); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for PredicateType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("PredicateType"); |
| formatter.field("lifetimes", &self.lifetimes); |
| formatter.field("bounded_ty", &self.bounded_ty); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("bounds", &self.bounds); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for QSelf { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("QSelf"); |
| formatter.field("lt_token", &self.lt_token); |
| formatter.field("ty", &self.ty); |
| formatter.field("position", &self.position); |
| formatter.field("as_token", &self.as_token); |
| formatter.field("gt_token", &self.gt_token); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for RangeLimits { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| RangeLimits::HalfOpen(v0) => { |
| let mut formatter = formatter.debug_tuple("HalfOpen"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| RangeLimits::Closed(v0) => { |
| let mut formatter = formatter.debug_tuple("Closed"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Receiver { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Receiver"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("reference", &self.reference); |
| formatter.field("mutability", &self.mutability); |
| formatter.field("self_token", &self.self_token); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for ReturnType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| ReturnType::Default => formatter.write_str("Default"), |
| ReturnType::Type(v0, v1) => { |
| let mut formatter = formatter.debug_tuple("Type"); |
| formatter.field(v0); |
| formatter.field(v1); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Signature { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Signature"); |
| formatter.field("constness", &self.constness); |
| formatter.field("asyncness", &self.asyncness); |
| formatter.field("unsafety", &self.unsafety); |
| formatter.field("abi", &self.abi); |
| formatter.field("fn_token", &self.fn_token); |
| formatter.field("ident", &self.ident); |
| formatter.field("generics", &self.generics); |
| formatter.field("paren_token", &self.paren_token); |
| formatter.field("inputs", &self.inputs); |
| formatter.field("variadic", &self.variadic); |
| formatter.field("output", &self.output); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TraitBound { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("TraitBound"); |
| formatter.field("paren_token", &self.paren_token); |
| formatter.field("modifier", &self.modifier); |
| formatter.field("lifetimes", &self.lifetimes); |
| formatter.field("path", &self.path); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TraitBoundModifier { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| TraitBoundModifier::None => formatter.write_str("None"), |
| TraitBoundModifier::Maybe(v0) => { |
| let mut formatter = formatter.debug_tuple("Maybe"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TraitItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TraitItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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() |
| } |
| #[cfg(syn_no_non_exhaustive)] |
| _ => unreachable!(), |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TypeArray { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TypeParam { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("TypeParam"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("ident", &self.ident); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("bounds", &self.bounds); |
| formatter.field("eq_token", &self.eq_token); |
| formatter.field("default", &self.default); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for TypeParamBound { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UseGlob { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("UseGlob"); |
| formatter.field("star_token", &self.star_token); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UseGroup { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("UseGroup"); |
| formatter.field("brace_token", &self.brace_token); |
| formatter.field("items", &self.items); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UseName { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("UseName"); |
| formatter.field("ident", &self.ident); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UsePath { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("UsePath"); |
| formatter.field("ident", &self.ident); |
| formatter.field("colon2_token", &self.colon2_token); |
| formatter.field("tree", &self.tree); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UseRename { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("UseRename"); |
| formatter.field("ident", &self.ident); |
| formatter.field("as_token", &self.as_token); |
| formatter.field("rename", &self.rename); |
| formatter.finish() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for UseTree { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Variadic { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Variadic"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("dots", &self.dots); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for Variant { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("Variant"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("ident", &self.ident); |
| formatter.field("fields", &self.fields); |
| formatter.field("discriminant", &self.discriminant); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| 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"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for WhereClause { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("WhereClause"); |
| formatter.field("where_token", &self.where_token); |
| formatter.field("predicates", &self.predicates); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for WherePredicate { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 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() |
| } |
| } |
| } |
| } |