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