| // This file is @generated by syn-internal-codegen. |
| // It is not intended for manual editing. |
| |
| #![allow(unknown_lints, non_local_definitions)] |
| use std::fmt::{self, Debug}; |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::AngleBracketedGenericArguments { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "AngleBracketedGenericArguments") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::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 crate::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 crate::AttrStyle { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("AttrStyle::")?; |
| match self { |
| crate::AttrStyle::Outer => formatter.write_str("Outer"), |
| crate::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 crate::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 crate::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 crate::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 crate::BinOp { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("BinOp::")?; |
| match self { |
| crate::BinOp::Add(v0) => { |
| let mut formatter = formatter.debug_tuple("Add"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Sub(v0) => { |
| let mut formatter = formatter.debug_tuple("Sub"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Mul(v0) => { |
| let mut formatter = formatter.debug_tuple("Mul"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Div(v0) => { |
| let mut formatter = formatter.debug_tuple("Div"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Rem(v0) => { |
| let mut formatter = formatter.debug_tuple("Rem"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::And(v0) => { |
| let mut formatter = formatter.debug_tuple("And"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Or(v0) => { |
| let mut formatter = formatter.debug_tuple("Or"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitXor(v0) => { |
| let mut formatter = formatter.debug_tuple("BitXor"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitAnd(v0) => { |
| let mut formatter = formatter.debug_tuple("BitAnd"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitOr(v0) => { |
| let mut formatter = formatter.debug_tuple("BitOr"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Shl(v0) => { |
| let mut formatter = formatter.debug_tuple("Shl"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Shr(v0) => { |
| let mut formatter = formatter.debug_tuple("Shr"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Eq(v0) => { |
| let mut formatter = formatter.debug_tuple("Eq"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Lt(v0) => { |
| let mut formatter = formatter.debug_tuple("Lt"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Le(v0) => { |
| let mut formatter = formatter.debug_tuple("Le"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Ne(v0) => { |
| let mut formatter = formatter.debug_tuple("Ne"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Ge(v0) => { |
| let mut formatter = formatter.debug_tuple("Ge"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::Gt(v0) => { |
| let mut formatter = formatter.debug_tuple("Gt"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::AddAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("AddAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::SubAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("SubAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::MulAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("MulAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::DivAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("DivAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::RemAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("RemAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitXorAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("BitXorAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitAndAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("BitAndAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::BitOrAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("BitOrAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::BinOp::ShlAssign(v0) => { |
| let mut formatter = formatter.debug_tuple("ShlAssign"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::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 crate::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 crate::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 crate::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 crate::Data { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Data::")?; |
| match self { |
| crate::Data::Struct(v0) => v0.debug(formatter, "Struct"), |
| crate::Data::Enum(v0) => v0.debug(formatter, "Enum"), |
| crate::Data::Union(v0) => v0.debug(formatter, "Union"), |
| } |
| } |
| } |
| #[cfg(feature = "derive")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::DataEnum { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "DataEnum") |
| } |
| } |
| #[cfg(feature = "derive")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "derive")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::DataStruct { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "DataStruct") |
| } |
| } |
| #[cfg(feature = "derive")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "derive")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::DataUnion { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "DataUnion") |
| } |
| } |
| #[cfg(feature = "derive")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "derive")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::Expr { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Expr::")?; |
| match self { |
| #[cfg(feature = "full")] |
| crate::Expr::Array(v0) => v0.debug(formatter, "Array"), |
| #[cfg(feature = "full")] |
| crate::Expr::Assign(v0) => v0.debug(formatter, "Assign"), |
| #[cfg(feature = "full")] |
| crate::Expr::Async(v0) => v0.debug(formatter, "Async"), |
| #[cfg(feature = "full")] |
| crate::Expr::Await(v0) => v0.debug(formatter, "Await"), |
| crate::Expr::Binary(v0) => v0.debug(formatter, "Binary"), |
| #[cfg(feature = "full")] |
| crate::Expr::Block(v0) => v0.debug(formatter, "Block"), |
| #[cfg(feature = "full")] |
| crate::Expr::Break(v0) => v0.debug(formatter, "Break"), |
| crate::Expr::Call(v0) => v0.debug(formatter, "Call"), |
| crate::Expr::Cast(v0) => v0.debug(formatter, "Cast"), |
| #[cfg(feature = "full")] |
| crate::Expr::Closure(v0) => v0.debug(formatter, "Closure"), |
| #[cfg(feature = "full")] |
| crate::Expr::Const(v0) => v0.debug(formatter, "Const"), |
| #[cfg(feature = "full")] |
| crate::Expr::Continue(v0) => v0.debug(formatter, "Continue"), |
| crate::Expr::Field(v0) => v0.debug(formatter, "Field"), |
| #[cfg(feature = "full")] |
| crate::Expr::ForLoop(v0) => v0.debug(formatter, "ForLoop"), |
| crate::Expr::Group(v0) => v0.debug(formatter, "Group"), |
| #[cfg(feature = "full")] |
| crate::Expr::If(v0) => v0.debug(formatter, "If"), |
| crate::Expr::Index(v0) => v0.debug(formatter, "Index"), |
| #[cfg(feature = "full")] |
| crate::Expr::Infer(v0) => v0.debug(formatter, "Infer"), |
| #[cfg(feature = "full")] |
| crate::Expr::Let(v0) => v0.debug(formatter, "Let"), |
| crate::Expr::Lit(v0) => v0.debug(formatter, "Lit"), |
| #[cfg(feature = "full")] |
| crate::Expr::Loop(v0) => v0.debug(formatter, "Loop"), |
| crate::Expr::Macro(v0) => v0.debug(formatter, "Macro"), |
| #[cfg(feature = "full")] |
| crate::Expr::Match(v0) => v0.debug(formatter, "Match"), |
| crate::Expr::MethodCall(v0) => v0.debug(formatter, "MethodCall"), |
| crate::Expr::Paren(v0) => v0.debug(formatter, "Paren"), |
| crate::Expr::Path(v0) => v0.debug(formatter, "Path"), |
| #[cfg(feature = "full")] |
| crate::Expr::Range(v0) => v0.debug(formatter, "Range"), |
| crate::Expr::Reference(v0) => v0.debug(formatter, "Reference"), |
| #[cfg(feature = "full")] |
| crate::Expr::Repeat(v0) => v0.debug(formatter, "Repeat"), |
| #[cfg(feature = "full")] |
| crate::Expr::Return(v0) => v0.debug(formatter, "Return"), |
| crate::Expr::Struct(v0) => v0.debug(formatter, "Struct"), |
| #[cfg(feature = "full")] |
| crate::Expr::Try(v0) => v0.debug(formatter, "Try"), |
| #[cfg(feature = "full")] |
| crate::Expr::TryBlock(v0) => v0.debug(formatter, "TryBlock"), |
| #[cfg(feature = "full")] |
| crate::Expr::Tuple(v0) => v0.debug(formatter, "Tuple"), |
| crate::Expr::Unary(v0) => v0.debug(formatter, "Unary"), |
| #[cfg(feature = "full")] |
| crate::Expr::Unsafe(v0) => v0.debug(formatter, "Unsafe"), |
| crate::Expr::Verbatim(v0) => { |
| let mut formatter = formatter.debug_tuple("Verbatim"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| #[cfg(feature = "full")] |
| crate::Expr::While(v0) => v0.debug(formatter, "While"), |
| #[cfg(feature = "full")] |
| crate::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 crate::ExprArray { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprArray") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprAssign { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprAssign") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprAsync { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprAsync") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprAwait { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprAwait") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprBinary { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprBinary") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprBlock { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprBlock") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprBreak { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprBreak") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprCall { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprCall") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprCast { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprCast") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprClosure { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprClosure") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprConst") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprContinue { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprContinue") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprField { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprField") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprForLoop { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprForLoop") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprGroup { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprGroup") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprIf { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprIf") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprIndex { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprIndex") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprInfer { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprInfer") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprLet { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprLet") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprLit { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprLit") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprLoop { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprLoop") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprMacro") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprMatch { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprMatch") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprMethodCall { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprMethodCall") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprParen { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprParen") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprPath { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprPath") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprRange { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprRange") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprReference { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprReference") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprRepeat { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprRepeat") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprReturn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprReturn") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprStruct { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprStruct") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprTry { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprTry") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprTryBlock { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprTryBlock") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprTuple { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprTuple") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprUnary { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprUnary") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprUnsafe { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprUnsafe") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprWhile { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprWhile") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ExprYield { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ExprYield") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::FieldMutability { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("FieldMutability::")?; |
| match self { |
| crate::FieldMutability::None => formatter.write_str("None"), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::FieldPat { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| let mut formatter = formatter.debug_struct("FieldPat"); |
| formatter.field("attrs", &self.attrs); |
| formatter.field("member", &self.member); |
| formatter.field("colon_token", &self.colon_token); |
| formatter.field("pat", &self.pat); |
| formatter.finish() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::Fields { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Fields::")?; |
| match self { |
| crate::Fields::Named(v0) => v0.debug(formatter, "Named"), |
| crate::Fields::Unnamed(v0) => v0.debug(formatter, "Unnamed"), |
| crate::Fields::Unit => formatter.write_str("Unit"), |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::FieldsNamed { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "FieldsNamed") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::FieldsUnnamed { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "FieldsUnnamed") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::FnArg { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("FnArg::")?; |
| match self { |
| crate::FnArg::Receiver(v0) => { |
| let mut formatter = formatter.debug_tuple("Receiver"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::ForeignItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("ForeignItem::")?; |
| match self { |
| crate::ForeignItem::Fn(v0) => v0.debug(formatter, "Fn"), |
| crate::ForeignItem::Static(v0) => v0.debug(formatter, "Static"), |
| crate::ForeignItem::Type(v0) => v0.debug(formatter, "Type"), |
| crate::ForeignItem::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::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 crate::ForeignItemFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ForeignItemFn") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ForeignItemMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ForeignItemMacro") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ForeignItemStatic { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ForeignItemStatic") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ForeignItemType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ForeignItemType") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::GenericArgument { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("GenericArgument::")?; |
| match self { |
| crate::GenericArgument::Lifetime(v0) => { |
| let mut formatter = formatter.debug_tuple("Lifetime"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::GenericArgument::Type(v0) => { |
| let mut formatter = formatter.debug_tuple("Type"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::GenericArgument::Const(v0) => { |
| let mut formatter = formatter.debug_tuple("Const"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::GenericArgument::AssocType(v0) => { |
| let mut formatter = formatter.debug_tuple("AssocType"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::GenericArgument::AssocConst(v0) => { |
| let mut formatter = formatter.debug_tuple("AssocConst"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::GenericParam { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("GenericParam::")?; |
| match self { |
| crate::GenericParam::Lifetime(v0) => { |
| let mut formatter = formatter.debug_tuple("Lifetime"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::GenericParam::Type(v0) => { |
| let mut formatter = formatter.debug_tuple("Type"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::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 crate::ImplItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("ImplItem::")?; |
| match self { |
| crate::ImplItem::Const(v0) => v0.debug(formatter, "Const"), |
| crate::ImplItem::Fn(v0) => v0.debug(formatter, "Fn"), |
| crate::ImplItem::Type(v0) => v0.debug(formatter, "Type"), |
| crate::ImplItem::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::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 crate::ImplItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ImplItemConst") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ImplItemFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ImplItemFn") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ImplItemMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ImplItemMacro") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ImplItemType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ImplItemType") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::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 crate::Item { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Item::")?; |
| match self { |
| crate::Item::Const(v0) => v0.debug(formatter, "Const"), |
| crate::Item::Enum(v0) => v0.debug(formatter, "Enum"), |
| crate::Item::ExternCrate(v0) => v0.debug(formatter, "ExternCrate"), |
| crate::Item::Fn(v0) => v0.debug(formatter, "Fn"), |
| crate::Item::ForeignMod(v0) => v0.debug(formatter, "ForeignMod"), |
| crate::Item::Impl(v0) => v0.debug(formatter, "Impl"), |
| crate::Item::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::Item::Mod(v0) => v0.debug(formatter, "Mod"), |
| crate::Item::Static(v0) => v0.debug(formatter, "Static"), |
| crate::Item::Struct(v0) => v0.debug(formatter, "Struct"), |
| crate::Item::Trait(v0) => v0.debug(formatter, "Trait"), |
| crate::Item::TraitAlias(v0) => v0.debug(formatter, "TraitAlias"), |
| crate::Item::Type(v0) => v0.debug(formatter, "Type"), |
| crate::Item::Union(v0) => v0.debug(formatter, "Union"), |
| crate::Item::Use(v0) => v0.debug(formatter, "Use"), |
| crate::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 crate::ItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemConst") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemEnum { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemEnum") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemExternCrate { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemExternCrate") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemFn") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemForeignMod { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemForeignMod") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemImpl { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemImpl") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemMacro") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemMod { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemMod") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemStatic { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemStatic") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemStruct { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemStruct") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemTrait { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemTrait") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemTraitAlias { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemTraitAlias") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemType") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemUnion { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemUnion") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ItemUse { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ItemUse") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::Lifetime { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "Lifetime") |
| } |
| } |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::Lit { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Lit::")?; |
| match self { |
| crate::Lit::Str(v0) => v0.debug(formatter, "Str"), |
| crate::Lit::ByteStr(v0) => v0.debug(formatter, "ByteStr"), |
| crate::Lit::Byte(v0) => v0.debug(formatter, "Byte"), |
| crate::Lit::Char(v0) => v0.debug(formatter, "Char"), |
| crate::Lit::Int(v0) => v0.debug(formatter, "Int"), |
| crate::Lit::Float(v0) => v0.debug(formatter, "Float"), |
| crate::Lit::Bool(v0) => v0.debug(formatter, "Bool"), |
| crate::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 crate::Local { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "Local") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::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 crate::MacroDelimiter { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("MacroDelimiter::")?; |
| match self { |
| crate::MacroDelimiter::Paren(v0) => { |
| let mut formatter = formatter.debug_tuple("Paren"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::MacroDelimiter::Brace(v0) => { |
| let mut formatter = formatter.debug_tuple("Brace"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::Member { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Member::")?; |
| match self { |
| crate::Member::Named(v0) => { |
| let mut formatter = formatter.debug_tuple("Named"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::Meta { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Meta::")?; |
| match self { |
| crate::Meta::Path(v0) => v0.debug(formatter, "Path"), |
| crate::Meta::List(v0) => v0.debug(formatter, "List"), |
| crate::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 crate::MetaList { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "MetaList") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::MetaNameValue { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "MetaNameValue") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::ParenthesizedGenericArguments { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "ParenthesizedGenericArguments") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::Pat { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Pat::")?; |
| match self { |
| crate::Pat::Const(v0) => v0.debug(formatter, "Const"), |
| crate::Pat::Ident(v0) => v0.debug(formatter, "Ident"), |
| crate::Pat::Lit(v0) => v0.debug(formatter, "Lit"), |
| crate::Pat::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::Pat::Or(v0) => v0.debug(formatter, "Or"), |
| crate::Pat::Paren(v0) => v0.debug(formatter, "Paren"), |
| crate::Pat::Path(v0) => v0.debug(formatter, "Path"), |
| crate::Pat::Range(v0) => v0.debug(formatter, "Range"), |
| crate::Pat::Reference(v0) => v0.debug(formatter, "Reference"), |
| crate::Pat::Rest(v0) => v0.debug(formatter, "Rest"), |
| crate::Pat::Slice(v0) => v0.debug(formatter, "Slice"), |
| crate::Pat::Struct(v0) => v0.debug(formatter, "Struct"), |
| crate::Pat::Tuple(v0) => v0.debug(formatter, "Tuple"), |
| crate::Pat::TupleStruct(v0) => v0.debug(formatter, "TupleStruct"), |
| crate::Pat::Type(v0) => v0.debug(formatter, "Type"), |
| crate::Pat::Verbatim(v0) => { |
| let mut formatter = formatter.debug_tuple("Verbatim"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::Pat::Wild(v0) => v0.debug(formatter, "Wild"), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatIdent { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatIdent") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatOr { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatOr") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatParen { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatParen") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatReference { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatReference") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatRest { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatRest") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatSlice { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatSlice") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatStruct { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatStruct") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatTuple { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatTuple") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatTupleStruct { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatTupleStruct") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatType") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PatWild { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "PatWild") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::Path { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "Path") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::PathArguments { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("PathArguments::")?; |
| match self { |
| crate::PathArguments::None => formatter.write_str("None"), |
| crate::PathArguments::AngleBracketed(v0) => { |
| v0.debug(formatter, "AngleBracketed") |
| } |
| crate::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 crate::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 crate::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 crate::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 crate::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 crate::RangeLimits { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("RangeLimits::")?; |
| match self { |
| crate::RangeLimits::HalfOpen(v0) => { |
| let mut formatter = formatter.debug_tuple("HalfOpen"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::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 crate::ReturnType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("ReturnType::")?; |
| match self { |
| crate::ReturnType::Default => formatter.write_str("Default"), |
| crate::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 crate::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 crate::StaticMutability { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("StaticMutability::")?; |
| match self { |
| crate::StaticMutability::Mut(v0) => { |
| let mut formatter = formatter.debug_tuple("Mut"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::StaticMutability::None => formatter.write_str("None"), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::Stmt { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Stmt::")?; |
| match self { |
| crate::Stmt::Local(v0) => v0.debug(formatter, "Local"), |
| crate::Stmt::Item(v0) => { |
| let mut formatter = formatter.debug_tuple("Item"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::Stmt::Expr(v0, v1) => { |
| let mut formatter = formatter.debug_tuple("Expr"); |
| formatter.field(v0); |
| formatter.field(v1); |
| formatter.finish() |
| } |
| crate::Stmt::Macro(v0) => v0.debug(formatter, "Macro"), |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::StmtMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "StmtMacro") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::TraitBoundModifier { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("TraitBoundModifier::")?; |
| match self { |
| crate::TraitBoundModifier::None => formatter.write_str("None"), |
| crate::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 crate::TraitItem { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("TraitItem::")?; |
| match self { |
| crate::TraitItem::Const(v0) => v0.debug(formatter, "Const"), |
| crate::TraitItem::Fn(v0) => v0.debug(formatter, "Fn"), |
| crate::TraitItem::Type(v0) => v0.debug(formatter, "Type"), |
| crate::TraitItem::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::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 crate::TraitItemConst { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TraitItemConst") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TraitItemFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TraitItemFn") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TraitItemMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TraitItemMacro") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(feature = "full")] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TraitItemType { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TraitItemType") |
| } |
| } |
| #[cfg(feature = "full")] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::Type { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Type::")?; |
| match self { |
| crate::Type::Array(v0) => v0.debug(formatter, "Array"), |
| crate::Type::BareFn(v0) => v0.debug(formatter, "BareFn"), |
| crate::Type::Group(v0) => v0.debug(formatter, "Group"), |
| crate::Type::ImplTrait(v0) => v0.debug(formatter, "ImplTrait"), |
| crate::Type::Infer(v0) => v0.debug(formatter, "Infer"), |
| crate::Type::Macro(v0) => v0.debug(formatter, "Macro"), |
| crate::Type::Never(v0) => v0.debug(formatter, "Never"), |
| crate::Type::Paren(v0) => v0.debug(formatter, "Paren"), |
| crate::Type::Path(v0) => v0.debug(formatter, "Path"), |
| crate::Type::Ptr(v0) => v0.debug(formatter, "Ptr"), |
| crate::Type::Reference(v0) => v0.debug(formatter, "Reference"), |
| crate::Type::Slice(v0) => v0.debug(formatter, "Slice"), |
| crate::Type::TraitObject(v0) => v0.debug(formatter, "TraitObject"), |
| crate::Type::Tuple(v0) => v0.debug(formatter, "Tuple"), |
| crate::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 crate::TypeArray { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeArray") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeBareFn { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeBareFn") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeGroup { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeGroup") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeImplTrait { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeImplTrait") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeInfer { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeInfer") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeMacro { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeMacro") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeNever { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeNever") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::TypeParamBound { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("TypeParamBound::")?; |
| match self { |
| crate::TypeParamBound::Trait(v0) => { |
| let mut formatter = formatter.debug_tuple("Trait"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::TypeParamBound::Lifetime(v0) => v0.debug(formatter, "Lifetime"), |
| crate::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 crate::TypeParen { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeParen") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypePath { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypePath") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypePtr { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypePtr") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeReference { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeReference") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeSlice { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeSlice") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeTraitObject { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeTraitObject") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::TypeTuple { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "TypeTuple") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::UnOp { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("UnOp::")?; |
| match self { |
| crate::UnOp::Deref(v0) => { |
| let mut formatter = formatter.debug_tuple("Deref"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::UnOp::Not(v0) => { |
| let mut formatter = formatter.debug_tuple("Not"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::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 crate::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 crate::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 crate::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 crate::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 crate::UseTree { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("UseTree::")?; |
| match self { |
| crate::UseTree::Path(v0) => { |
| let mut formatter = formatter.debug_tuple("Path"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::UseTree::Name(v0) => { |
| let mut formatter = formatter.debug_tuple("Name"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::UseTree::Rename(v0) => { |
| let mut formatter = formatter.debug_tuple("Rename"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::UseTree::Glob(v0) => { |
| let mut formatter = formatter.debug_tuple("Glob"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::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 crate::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 crate::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 crate::VisRestricted { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| self.debug(formatter, "VisRestricted") |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| impl crate::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() |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::Visibility { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("Visibility::")?; |
| match self { |
| crate::Visibility::Public(v0) => { |
| let mut formatter = formatter.debug_tuple("Public"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::Visibility::Restricted(v0) => v0.debug(formatter, "Restricted"), |
| crate::Visibility::Inherited => formatter.write_str("Inherited"), |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))] |
| impl Debug for crate::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 crate::WherePredicate { |
| fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| formatter.write_str("WherePredicate::")?; |
| match self { |
| crate::WherePredicate::Lifetime(v0) => { |
| let mut formatter = formatter.debug_tuple("Lifetime"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| crate::WherePredicate::Type(v0) => { |
| let mut formatter = formatter.debug_tuple("Type"); |
| formatter.field(v0); |
| formatter.finish() |
| } |
| } |
| } |
| } |
