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