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