Generate debug impls more appropriate for inline snapshot
diff --git a/tests/debug/gen.rs b/tests/debug/gen.rs
new file mode 100644
index 0000000..06b18ac
--- /dev/null
+++ b/tests/debug/gen.rs
@@ -0,0 +1,4533 @@
+// This file is @generated by syn-internal-codegen.
+// It is not intended for manual editing.
+
+use super::{Lite, RefCast};
+use std::fmt::{self, Debug};
+impl Debug for Lite<syn::Abi> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Abi");
+ formatter.field("name", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::LitStr>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.name)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::AngleBracketedGenericArguments> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("AngleBracketedGenericArguments");
+ formatter.field("colon2_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon2_token)
+ });
+ formatter.field("args", Lite(&self.value.args));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ArgCaptured> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ArgCaptured");
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ArgSelf> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ArgSelf");
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ArgSelfRef> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ArgSelfRef");
+ formatter.field("lifetime", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Lifetime>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lifetime)
+ });
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Arm> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Arm");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("leading_vert", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Or>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.leading_vert)
+ });
+ formatter.field("pats", Lite(&self.value.pats));
+ formatter.field("guard", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::If, Box<syn::Expr>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.guard)
+ });
+ formatter.field("body", Lite(&self.value.body));
+ formatter.field("comma", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Comma>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.comma)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::AttrStyle> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::AttrStyle::Outer => formatter.write_str("Outer"),
+ syn::AttrStyle::Inner(_v0) => {
+ let mut formatter = formatter.debug_tuple("Inner");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Attribute> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Attribute");
+ formatter.field("style", Lite(&self.value.style));
+ formatter.field("path", Lite(&self.value.path));
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::BareFnArg> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("BareFnArg");
+ formatter.field("name", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::BareFnArgName, syn::token::Colon)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.0), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.name)
+ });
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::BareFnArgName> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::BareFnArgName::Named(_v0) => {
+ let mut formatter = formatter.debug_tuple("Named");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::BareFnArgName::Wild(_v0) => {
+ let mut formatter = formatter.debug_tuple("Wild");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::BinOp> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::BinOp::Add(_v0) => {
+ let mut formatter = formatter.debug_tuple("Add");
+ formatter.finish()
+ }
+ syn::BinOp::Sub(_v0) => {
+ let mut formatter = formatter.debug_tuple("Sub");
+ formatter.finish()
+ }
+ syn::BinOp::Mul(_v0) => {
+ let mut formatter = formatter.debug_tuple("Mul");
+ formatter.finish()
+ }
+ syn::BinOp::Div(_v0) => {
+ let mut formatter = formatter.debug_tuple("Div");
+ formatter.finish()
+ }
+ syn::BinOp::Rem(_v0) => {
+ let mut formatter = formatter.debug_tuple("Rem");
+ formatter.finish()
+ }
+ syn::BinOp::And(_v0) => {
+ let mut formatter = formatter.debug_tuple("And");
+ formatter.finish()
+ }
+ syn::BinOp::Or(_v0) => {
+ let mut formatter = formatter.debug_tuple("Or");
+ formatter.finish()
+ }
+ syn::BinOp::BitXor(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitXor");
+ formatter.finish()
+ }
+ syn::BinOp::BitAnd(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitAnd");
+ formatter.finish()
+ }
+ syn::BinOp::BitOr(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitOr");
+ formatter.finish()
+ }
+ syn::BinOp::Shl(_v0) => {
+ let mut formatter = formatter.debug_tuple("Shl");
+ formatter.finish()
+ }
+ syn::BinOp::Shr(_v0) => {
+ let mut formatter = formatter.debug_tuple("Shr");
+ formatter.finish()
+ }
+ syn::BinOp::Eq(_v0) => {
+ let mut formatter = formatter.debug_tuple("Eq");
+ formatter.finish()
+ }
+ syn::BinOp::Lt(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lt");
+ formatter.finish()
+ }
+ syn::BinOp::Le(_v0) => {
+ let mut formatter = formatter.debug_tuple("Le");
+ formatter.finish()
+ }
+ syn::BinOp::Ne(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ne");
+ formatter.finish()
+ }
+ syn::BinOp::Ge(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ge");
+ formatter.finish()
+ }
+ syn::BinOp::Gt(_v0) => {
+ let mut formatter = formatter.debug_tuple("Gt");
+ formatter.finish()
+ }
+ syn::BinOp::AddEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("AddEq");
+ formatter.finish()
+ }
+ syn::BinOp::SubEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("SubEq");
+ formatter.finish()
+ }
+ syn::BinOp::MulEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("MulEq");
+ formatter.finish()
+ }
+ syn::BinOp::DivEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("DivEq");
+ formatter.finish()
+ }
+ syn::BinOp::RemEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("RemEq");
+ formatter.finish()
+ }
+ syn::BinOp::BitXorEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitXorEq");
+ formatter.finish()
+ }
+ syn::BinOp::BitAndEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitAndEq");
+ formatter.finish()
+ }
+ syn::BinOp::BitOrEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("BitOrEq");
+ formatter.finish()
+ }
+ syn::BinOp::ShlEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("ShlEq");
+ formatter.finish()
+ }
+ syn::BinOp::ShrEq(_v0) => {
+ let mut formatter = formatter.debug_tuple("ShrEq");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Binding> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Binding");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Block> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Block");
+ formatter.field("stmts", Lite(&self.value.stmts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::BoundLifetimes> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("BoundLifetimes");
+ formatter.field("lifetimes", Lite(&self.value.lifetimes));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ConstParam> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ConstParam");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("eq_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Eq>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.eq_token)
+ });
+ formatter.field("default", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Expr>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.default)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Constraint> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Constraint");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Data> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Data::Struct(_v0) => {
+ let mut formatter = formatter.debug_tuple("Struct");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Data::Enum(_v0) => {
+ let mut formatter = formatter.debug_tuple("Enum");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Data::Union(_v0) => {
+ let mut formatter = formatter.debug_tuple("Union");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::DataEnum> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("DataEnum");
+ formatter.field("variants", Lite(&self.value.variants));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::DataStruct> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("DataStruct");
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::DataUnion> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("DataUnion");
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::DeriveInput> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("DeriveInput");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("data", Lite(&self.value.data));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Expr> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Expr::Box(_v0) => {
+ let mut formatter = formatter.debug_tuple("Box");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::InPlace(_v0) => {
+ let mut formatter = formatter.debug_tuple("InPlace");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Array(_v0) => {
+ let mut formatter = formatter.debug_tuple("Array");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Call(_v0) => {
+ let mut formatter = formatter.debug_tuple("Call");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::MethodCall(_v0) => {
+ let mut formatter = formatter.debug_tuple("MethodCall");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Tuple(_v0) => {
+ let mut formatter = formatter.debug_tuple("Tuple");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Binary(_v0) => {
+ let mut formatter = formatter.debug_tuple("Binary");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Unary(_v0) => {
+ let mut formatter = formatter.debug_tuple("Unary");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Lit(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lit");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Cast(_v0) => {
+ let mut formatter = formatter.debug_tuple("Cast");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Let(_v0) => {
+ let mut formatter = formatter.debug_tuple("Let");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::If(_v0) => {
+ let mut formatter = formatter.debug_tuple("If");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::While(_v0) => {
+ let mut formatter = formatter.debug_tuple("While");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::ForLoop(_v0) => {
+ let mut formatter = formatter.debug_tuple("ForLoop");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Loop(_v0) => {
+ let mut formatter = formatter.debug_tuple("Loop");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Match(_v0) => {
+ let mut formatter = formatter.debug_tuple("Match");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Closure(_v0) => {
+ let mut formatter = formatter.debug_tuple("Closure");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Unsafe(_v0) => {
+ let mut formatter = formatter.debug_tuple("Unsafe");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Block(_v0) => {
+ let mut formatter = formatter.debug_tuple("Block");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Assign(_v0) => {
+ let mut formatter = formatter.debug_tuple("Assign");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::AssignOp(_v0) => {
+ let mut formatter = formatter.debug_tuple("AssignOp");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Field(_v0) => {
+ let mut formatter = formatter.debug_tuple("Field");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Index(_v0) => {
+ let mut formatter = formatter.debug_tuple("Index");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Range(_v0) => {
+ let mut formatter = formatter.debug_tuple("Range");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Path(_v0) => {
+ let mut formatter = formatter.debug_tuple("Path");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Reference(_v0) => {
+ let mut formatter = formatter.debug_tuple("Reference");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Break(_v0) => {
+ let mut formatter = formatter.debug_tuple("Break");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Continue(_v0) => {
+ let mut formatter = formatter.debug_tuple("Continue");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Return(_v0) => {
+ let mut formatter = formatter.debug_tuple("Return");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Struct(_v0) => {
+ let mut formatter = formatter.debug_tuple("Struct");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Repeat(_v0) => {
+ let mut formatter = formatter.debug_tuple("Repeat");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Paren(_v0) => {
+ let mut formatter = formatter.debug_tuple("Paren");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Group(_v0) => {
+ let mut formatter = formatter.debug_tuple("Group");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Try(_v0) => {
+ let mut formatter = formatter.debug_tuple("Try");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Async(_v0) => {
+ let mut formatter = formatter.debug_tuple("Async");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::TryBlock(_v0) => {
+ let mut formatter = formatter.debug_tuple("TryBlock");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Yield(_v0) => {
+ let mut formatter = formatter.debug_tuple("Yield");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Expr::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ExprArray> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprArray");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("elems", Lite(&self.value.elems));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprAssign> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprAssign");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("left", Lite(&self.value.left));
+ formatter.field("right", Lite(&self.value.right));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprAssignOp> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprAssignOp");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("left", Lite(&self.value.left));
+ formatter.field("op", Lite(&self.value.op));
+ formatter.field("right", Lite(&self.value.right));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprAsync> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprAsync");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("capture", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Move>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.capture)
+ });
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprBinary> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprBinary");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("left", Lite(&self.value.left));
+ formatter.field("op", Lite(&self.value.op));
+ formatter.field("right", Lite(&self.value.right));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprBlock> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprBlock");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Label>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprBox> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprBox");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprBreak> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprBreak");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Lifetime>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.field("expr", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.expr)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprCall> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprCall");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("func", Lite(&self.value.func));
+ formatter.field("args", Lite(&self.value.args));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprCast> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprCast");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprClosure> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprClosure");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("asyncness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Async>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.asyncness)
+ });
+ formatter.field("movability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Static>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.movability)
+ });
+ formatter.field("capture", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Move>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.capture)
+ });
+ formatter.field("inputs", Lite(&self.value.inputs));
+ formatter.field("output", Lite(&self.value.output));
+ formatter.field("body", Lite(&self.value.body));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprContinue> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprContinue");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Lifetime>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprField> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprField");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("base", Lite(&self.value.base));
+ formatter.field("member", Lite(&self.value.member));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprForLoop> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprForLoop");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Label>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("body", Lite(&self.value.body));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprGroup> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprGroup");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprIf> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprIf");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("cond", Lite(&self.value.cond));
+ formatter.field("then_branch", Lite(&self.value.then_branch));
+ formatter.field("else_branch", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Else, Box<syn::Expr>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.else_branch)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprInPlace> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprInPlace");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("place", Lite(&self.value.place));
+ formatter.field("value", Lite(&self.value.value));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprIndex> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprIndex");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("index", Lite(&self.value.index));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprLet> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprLet");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("pats", Lite(&self.value.pats));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprLit> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprLit");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("lit", Lite(&self.value.lit));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprLoop> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprLoop");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Label>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.field("body", Lite(&self.value.body));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprMacro");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprMatch> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprMatch");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("arms", Lite(&self.value.arms));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprMethodCall> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprMethodCall");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("receiver", Lite(&self.value.receiver));
+ formatter.field("method", Lite(&self.value.method));
+ formatter.field("turbofish", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::MethodTurbofish>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.turbofish)
+ });
+ formatter.field("args", Lite(&self.value.args));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprParen> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprParen");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprPath> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprPath");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("qself", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::QSelf>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.qself)
+ });
+ formatter.field("path", Lite(&self.value.path));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprRange> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprRange");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("from", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.from)
+ });
+ formatter.field("limits", Lite(&self.value.limits));
+ formatter.field("to", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.to)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprReference> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprReference");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprRepeat> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprRepeat");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("len", Lite(&self.value.len));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprReturn> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprReturn");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.expr)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprStruct> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprStruct");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("path", Lite(&self.value.path));
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.field("dot2_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.dot2_token)
+ });
+ formatter.field("rest", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.rest)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprTry> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprTry");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprTryBlock> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprTryBlock");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprTuple> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprTuple");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("elems", Lite(&self.value.elems));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprType");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprUnary> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprUnary");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("op", Lite(&self.value.op));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprUnsafe> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprUnsafe");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprWhile> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprWhile");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("label", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Label>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.label)
+ });
+ formatter.field("cond", Lite(&self.value.cond));
+ formatter.field("body", Lite(&self.value.body));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ExprYield> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ExprYield");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("expr", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Expr>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.expr)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Field> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Field");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<proc_macro2::Ident>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.ident)
+ });
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::FieldPat> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("FieldPat");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("member", Lite(&self.value.member));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::FieldValue> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("FieldValue");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("member", Lite(&self.value.member));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Fields> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Fields::Named(_v0) => {
+ let mut formatter = formatter.debug_tuple("Named");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Fields::Unnamed(_v0) => {
+ let mut formatter = formatter.debug_tuple("Unnamed");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Fields::Unit => formatter.write_str("Unit"),
+ }
+ }
+}
+impl Debug for Lite<syn::FieldsNamed> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("FieldsNamed");
+ formatter.field("named", Lite(&self.value.named));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::FieldsUnnamed> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("FieldsUnnamed");
+ formatter.field("unnamed", Lite(&self.value.unnamed));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::File> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("File");
+ formatter.field("shebang", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<String>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.shebang)
+ });
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("items", Lite(&self.value.items));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::FnArg> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::FnArg::SelfRef(_v0) => {
+ let mut formatter = formatter.debug_tuple("SelfRef");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::FnArg::SelfValue(_v0) => {
+ let mut formatter = formatter.debug_tuple("SelfValue");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::FnArg::Captured(_v0) => {
+ let mut formatter = formatter.debug_tuple("Captured");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::FnArg::Inferred(_v0) => {
+ let mut formatter = formatter.debug_tuple("Inferred");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::FnArg::Ignored(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ignored");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::FnDecl> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("FnDecl");
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("inputs", Lite(&self.value.inputs));
+ formatter.field("variadic", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot3>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.variadic)
+ });
+ formatter.field("output", Lite(&self.value.output));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ForeignItem> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::ForeignItem::Fn(_v0) => {
+ let mut formatter = formatter.debug_tuple("Fn");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ForeignItem::Static(_v0) => {
+ let mut formatter = formatter.debug_tuple("Static");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ForeignItem::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ForeignItem::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ForeignItem::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ForeignItemFn> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ForeignItemFn");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("decl", Lite(&self.value.decl));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ForeignItemMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ForeignItemMacro");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ForeignItemStatic> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ForeignItemStatic");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ForeignItemType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ForeignItemType");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ForeignItemVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ForeignItemVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::GenericArgument> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::GenericArgument::Lifetime(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lifetime");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericArgument::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericArgument::Binding(_v0) => {
+ let mut formatter = formatter.debug_tuple("Binding");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericArgument::Constraint(_v0) => {
+ let mut formatter = formatter.debug_tuple("Constraint");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericArgument::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::GenericMethodArgument> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::GenericMethodArgument::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericMethodArgument::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::GenericParam> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::GenericParam::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericParam::Lifetime(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lifetime");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::GenericParam::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Generics> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Generics");
+ formatter.field("lt_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Lt>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lt_token)
+ });
+ formatter.field("params", Lite(&self.value.params));
+ formatter.field("gt_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Gt>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.gt_token)
+ });
+ formatter.field("where_clause", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::WhereClause>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.where_clause)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItem> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::ImplItem::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ImplItem::Method(_v0) => {
+ let mut formatter = formatter.debug_tuple("Method");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ImplItem::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ImplItem::Existential(_v0) => {
+ let mut formatter = formatter.debug_tuple("Existential");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ImplItem::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::ImplItem::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ImplItemConst> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemConst");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("defaultness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Default>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.defaultness)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItemExistential> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemExistential");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItemMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemMacro");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItemMethod> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemMethod");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("defaultness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Default>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.defaultness)
+ });
+ formatter.field("sig", Lite(&self.value.sig));
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItemType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemType");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("defaultness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Default>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.defaultness)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ImplItemVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ImplItemVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Index> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Index");
+ formatter.field("index", Lite(&self.value.index));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Item> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Item::ExternCrate(_v0) => {
+ let mut formatter = formatter.debug_tuple("ExternCrate");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Use(_v0) => {
+ let mut formatter = formatter.debug_tuple("Use");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Static(_v0) => {
+ let mut formatter = formatter.debug_tuple("Static");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Fn(_v0) => {
+ let mut formatter = formatter.debug_tuple("Fn");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Mod(_v0) => {
+ let mut formatter = formatter.debug_tuple("Mod");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::ForeignMod(_v0) => {
+ let mut formatter = formatter.debug_tuple("ForeignMod");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Existential(_v0) => {
+ let mut formatter = formatter.debug_tuple("Existential");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Struct(_v0) => {
+ let mut formatter = formatter.debug_tuple("Struct");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Enum(_v0) => {
+ let mut formatter = formatter.debug_tuple("Enum");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Union(_v0) => {
+ let mut formatter = formatter.debug_tuple("Union");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Trait(_v0) => {
+ let mut formatter = formatter.debug_tuple("Trait");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::TraitAlias(_v0) => {
+ let mut formatter = formatter.debug_tuple("TraitAlias");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Impl(_v0) => {
+ let mut formatter = formatter.debug_tuple("Impl");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Macro2(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro2");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Item::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ItemConst> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemConst");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemEnum> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemEnum");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("variants", Lite(&self.value.variants));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemExistential> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemExistential");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemExternCrate> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemExternCrate");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("rename", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::As, proc_macro2::Ident)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.rename)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemFn> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemFn");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("constness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Const>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.constness)
+ });
+ formatter.field("unsafety", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Unsafe>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.unsafety)
+ });
+ formatter.field("asyncness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Async>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.asyncness)
+ });
+ formatter.field("abi", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Abi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.abi)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("decl", Lite(&self.value.decl));
+ formatter.field("block", Lite(&self.value.block));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemForeignMod> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemForeignMod");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("abi", Lite(&self.value.abi));
+ formatter.field("items", Lite(&self.value.items));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemImpl> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemImpl");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("defaultness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Default>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.defaultness)
+ });
+ formatter.field("unsafety", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Unsafe>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.unsafety)
+ });
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("trait_", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(Option<syn::token::Bang>, syn::Path, syn::token::For)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(
+ &(
+ {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Bang>);
+ impl Debug for Print {
+ fn fmt(
+ &self,
+ formatter: &mut fmt::Formatter,
+ ) -> fmt::Result
+ {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&_val.0)
+ },
+ Lite(&_val.1),
+ ),
+ formatter,
+ )?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.trait_)
+ });
+ formatter.field("self_ty", Lite(&self.value.self_ty));
+ formatter.field("items", Lite(&self.value.items));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemMacro");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<proc_macro2::Ident>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.ident)
+ });
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemMacro2> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemMacro2");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("args", Lite(&self.value.args));
+ formatter.field("body", Lite(&self.value.body));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemMod> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemMod");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("content", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Brace, Vec<syn::Item>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.content)
+ });
+ formatter.field("semi", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemStatic> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemStatic");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemStruct> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemStruct");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemTrait> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemTrait");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("unsafety", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Unsafe>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.unsafety)
+ });
+ formatter.field("auto_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Auto>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.auto_token)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("supertraits", Lite(&self.value.supertraits));
+ formatter.field("items", Lite(&self.value.items));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemTraitAlias> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemTraitAlias");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemType");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemUnion> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemUnion");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemUse> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemUse");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("vis", Lite(&self.value.vis));
+ formatter.field("leading_colon", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.leading_colon)
+ });
+ formatter.field("tree", Lite(&self.value.tree));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::ItemVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ItemVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Label> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Label");
+ formatter.field("name", Lite(&self.value.name));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Lifetime> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Lifetime");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::LifetimeDef> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("LifetimeDef");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("lifetime", Lite(&self.value.lifetime));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Lit> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Lit::Str(_v0) => {
+ let mut formatter = formatter.debug_tuple("Str");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::ByteStr(_v0) => {
+ let mut formatter = formatter.debug_tuple("ByteStr");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Byte(_v0) => {
+ let mut formatter = formatter.debug_tuple("Byte");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Char(_v0) => {
+ let mut formatter = formatter.debug_tuple("Char");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Int(_v0) => {
+ let mut formatter = formatter.debug_tuple("Int");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Float(_v0) => {
+ let mut formatter = formatter.debug_tuple("Float");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Bool(_v0) => {
+ let mut formatter = formatter.debug_tuple("Bool");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Lit::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::LitBool> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("LitBool");
+ formatter.field("value", Lite(&self.value.value));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::LitByte> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitByteStr> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitChar> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitFloat> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitInt> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitStr> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value())
+ }
+}
+impl Debug for Lite<syn::LitVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("LitVerbatim");
+ formatter.field("token", Lite(&self.value.token));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Local> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Local");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("pats", Lite(&self.value.pats));
+ formatter.field("ty", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Colon, Box<syn::Type>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.ty)
+ });
+ formatter.field("init", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Eq, Box<syn::Expr>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.init)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Macro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Macro");
+ formatter.field("path", Lite(&self.value.path));
+ formatter.field("delimiter", Lite(&self.value.delimiter));
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::MacroDelimiter> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::MacroDelimiter::Paren(_v0) => {
+ let mut formatter = formatter.debug_tuple("Paren");
+ formatter.finish()
+ }
+ syn::MacroDelimiter::Brace(_v0) => {
+ let mut formatter = formatter.debug_tuple("Brace");
+ formatter.finish()
+ }
+ syn::MacroDelimiter::Bracket(_v0) => {
+ let mut formatter = formatter.debug_tuple("Bracket");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Member> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Member::Named(_v0) => {
+ let mut formatter = formatter.debug_tuple("Named");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Member::Unnamed(_v0) => {
+ let mut formatter = formatter.debug_tuple("Unnamed");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Meta> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Meta::Word(_v0) => {
+ let mut formatter = formatter.debug_tuple("Word");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Meta::List(_v0) => {
+ let mut formatter = formatter.debug_tuple("List");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Meta::NameValue(_v0) => {
+ let mut formatter = formatter.debug_tuple("NameValue");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::MetaList> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("MetaList");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("nested", Lite(&self.value.nested));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::MetaNameValue> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("MetaNameValue");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("lit", Lite(&self.value.lit));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::MethodSig> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("MethodSig");
+ formatter.field("constness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Const>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.constness)
+ });
+ formatter.field("unsafety", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Unsafe>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.unsafety)
+ });
+ formatter.field("asyncness", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Async>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.asyncness)
+ });
+ formatter.field("abi", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Abi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.abi)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("decl", Lite(&self.value.decl));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::MethodTurbofish> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("MethodTurbofish");
+ formatter.field("args", Lite(&self.value.args));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::NestedMeta> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::NestedMeta::Meta(_v0) => {
+ let mut formatter = formatter.debug_tuple("Meta");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::NestedMeta::Literal(_v0) => {
+ let mut formatter = formatter.debug_tuple("Literal");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ParenthesizedGenericArguments> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("ParenthesizedGenericArguments");
+ formatter.field("inputs", Lite(&self.value.inputs));
+ formatter.field("output", Lite(&self.value.output));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Pat> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Pat::Wild(_v0) => {
+ let mut formatter = formatter.debug_tuple("Wild");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Ident(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ident");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Struct(_v0) => {
+ let mut formatter = formatter.debug_tuple("Struct");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::TupleStruct(_v0) => {
+ let mut formatter = formatter.debug_tuple("TupleStruct");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Path(_v0) => {
+ let mut formatter = formatter.debug_tuple("Path");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Tuple(_v0) => {
+ let mut formatter = formatter.debug_tuple("Tuple");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Box(_v0) => {
+ let mut formatter = formatter.debug_tuple("Box");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Ref(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ref");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Lit(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lit");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Range(_v0) => {
+ let mut formatter = formatter.debug_tuple("Range");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Slice(_v0) => {
+ let mut formatter = formatter.debug_tuple("Slice");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Pat::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::PatBox> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatBox");
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatIdent> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatIdent");
+ formatter.field("by_ref", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Ref>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.by_ref)
+ });
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("subpat", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::At, Box<syn::Pat>)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.subpat)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatLit> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatLit");
+ formatter.field("expr", Lite(&self.value.expr));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatMacro");
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatPath> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatPath");
+ formatter.field("qself", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::QSelf>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.qself)
+ });
+ formatter.field("path", Lite(&self.value.path));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatRange> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatRange");
+ formatter.field("lo", Lite(&self.value.lo));
+ formatter.field("limits", Lite(&self.value.limits));
+ formatter.field("hi", Lite(&self.value.hi));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatRef> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatRef");
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatSlice> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatSlice");
+ formatter.field("front", Lite(&self.value.front));
+ formatter.field("middle", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<Box<syn::Pat>>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.middle)
+ });
+ formatter.field("dot2_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.dot2_token)
+ });
+ formatter.field("comma_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Comma>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.comma_token)
+ });
+ formatter.field("back", Lite(&self.value.back));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatStruct> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatStruct");
+ formatter.field("path", Lite(&self.value.path));
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.field("dot2_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.dot2_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatTuple> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatTuple");
+ formatter.field("front", Lite(&self.value.front));
+ formatter.field("dot2_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.dot2_token)
+ });
+ formatter.field("comma_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Comma>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.comma_token)
+ });
+ formatter.field("back", Lite(&self.value.back));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatTupleStruct> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatTupleStruct");
+ formatter.field("path", Lite(&self.value.path));
+ formatter.field("pat", Lite(&self.value.pat));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PatWild> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PatWild");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Path> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Path");
+ formatter.field("leading_colon", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon2>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.leading_colon)
+ });
+ formatter.field("segments", Lite(&self.value.segments));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PathArguments> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::PathArguments::None => formatter.write_str("None"),
+ syn::PathArguments::AngleBracketed(_v0) => {
+ let mut formatter = formatter.debug_tuple("AngleBracketed");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::PathArguments::Parenthesized(_v0) => {
+ let mut formatter = formatter.debug_tuple("Parenthesized");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::PathSegment> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PathSegment");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("arguments", Lite(&self.value.arguments));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PredicateEq> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PredicateEq");
+ formatter.field("lhs_ty", Lite(&self.value.lhs_ty));
+ formatter.field("rhs_ty", Lite(&self.value.rhs_ty));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PredicateLifetime> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PredicateLifetime");
+ formatter.field("lifetime", Lite(&self.value.lifetime));
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::PredicateType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("PredicateType");
+ formatter.field("lifetimes", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::BoundLifetimes>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lifetimes)
+ });
+ formatter.field("bounded_ty", Lite(&self.value.bounded_ty));
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::QSelf> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("QSelf");
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("position", Lite(&self.value.position));
+ formatter.field("as_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::As>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.as_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::RangeLimits> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::RangeLimits::HalfOpen(_v0) => {
+ let mut formatter = formatter.debug_tuple("HalfOpen");
+ formatter.finish()
+ }
+ syn::RangeLimits::Closed(_v0) => {
+ let mut formatter = formatter.debug_tuple("Closed");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::ReturnType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::ReturnType::Default => formatter.write_str("Default"),
+ syn::ReturnType::Type(_v0, _v1) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v1));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Stmt> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Stmt::Local(_v0) => {
+ let mut formatter = formatter.debug_tuple("Local");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Stmt::Item(_v0) => {
+ let mut formatter = formatter.debug_tuple("Item");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Stmt::Expr(_v0) => {
+ let mut formatter = formatter.debug_tuple("Expr");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Stmt::Semi(_v0, _v1) => {
+ let mut formatter = formatter.debug_tuple("Semi");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::TraitBound> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitBound");
+ formatter.field("paren_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Paren>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.paren_token)
+ });
+ formatter.field("modifier", Lite(&self.value.modifier));
+ formatter.field("lifetimes", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::BoundLifetimes>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lifetimes)
+ });
+ formatter.field("path", Lite(&self.value.path));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TraitBoundModifier> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::TraitBoundModifier::None => formatter.write_str("None"),
+ syn::TraitBoundModifier::Maybe(_v0) => {
+ let mut formatter = formatter.debug_tuple("Maybe");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::TraitItem> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::TraitItem::Const(_v0) => {
+ let mut formatter = formatter.debug_tuple("Const");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::TraitItem::Method(_v0) => {
+ let mut formatter = formatter.debug_tuple("Method");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::TraitItem::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::TraitItem::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::TraitItem::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::TraitItemConst> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitItemConst");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("ty", Lite(&self.value.ty));
+ formatter.field("default", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Eq, syn::Expr)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.default)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TraitItemMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitItemMacro");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TraitItemMethod> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitItemMethod");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("sig", Lite(&self.value.sig));
+ formatter.field("default", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Block>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.default)
+ });
+ formatter.field("semi_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Semi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.semi_token)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TraitItemType> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitItemType");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("generics", Lite(&self.value.generics));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.field("default", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Eq, syn::Type)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.default)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TraitItemVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TraitItemVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Type> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Type::Slice(_v0) => {
+ let mut formatter = formatter.debug_tuple("Slice");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Array(_v0) => {
+ let mut formatter = formatter.debug_tuple("Array");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Ptr(_v0) => {
+ let mut formatter = formatter.debug_tuple("Ptr");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Reference(_v0) => {
+ let mut formatter = formatter.debug_tuple("Reference");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::BareFn(_v0) => {
+ let mut formatter = formatter.debug_tuple("BareFn");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Never(_v0) => {
+ let mut formatter = formatter.debug_tuple("Never");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Tuple(_v0) => {
+ let mut formatter = formatter.debug_tuple("Tuple");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Path(_v0) => {
+ let mut formatter = formatter.debug_tuple("Path");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::TraitObject(_v0) => {
+ let mut formatter = formatter.debug_tuple("TraitObject");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::ImplTrait(_v0) => {
+ let mut formatter = formatter.debug_tuple("ImplTrait");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Paren(_v0) => {
+ let mut formatter = formatter.debug_tuple("Paren");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Group(_v0) => {
+ let mut formatter = formatter.debug_tuple("Group");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Infer(_v0) => {
+ let mut formatter = formatter.debug_tuple("Infer");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Macro(_v0) => {
+ let mut formatter = formatter.debug_tuple("Macro");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Type::Verbatim(_v0) => {
+ let mut formatter = formatter.debug_tuple("Verbatim");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::TypeArray> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeArray");
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.field("len", Lite(&self.value.len));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeBareFn> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeBareFn");
+ formatter.field("lifetimes", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::BoundLifetimes>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lifetimes)
+ });
+ formatter.field("unsafety", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Unsafe>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.unsafety)
+ });
+ formatter.field("abi", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Abi>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.abi)
+ });
+ formatter.field("inputs", Lite(&self.value.inputs));
+ formatter.field("variadic", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dot3>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.variadic)
+ });
+ formatter.field("output", Lite(&self.value.output));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeGroup> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeGroup");
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeImplTrait> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeImplTrait");
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeInfer> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeInfer");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeMacro> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeMacro");
+ formatter.field("mac", Lite(&self.value.mac));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeNever> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeNever");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeParam> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeParam");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("colon_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Colon>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.colon_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.field("eq_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Eq>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.eq_token)
+ });
+ formatter.field("default", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Type>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.default)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeParamBound> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::TypeParamBound::Trait(_v0) => {
+ let mut formatter = formatter.debug_tuple("Trait");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::TypeParamBound::Lifetime(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lifetime");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::TypeParen> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeParen");
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypePath> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypePath");
+ formatter.field("qself", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::QSelf>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.qself)
+ });
+ formatter.field("path", Lite(&self.value.path));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypePtr> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypePtr");
+ formatter.field("const_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Const>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.const_token)
+ });
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeReference> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeReference");
+ formatter.field("lifetime", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::Lifetime>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(_val), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.lifetime)
+ });
+ formatter.field("mutability", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Mut>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.mutability)
+ });
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeSlice> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeSlice");
+ formatter.field("elem", Lite(&self.value.elem));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeTraitObject> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeTraitObject");
+ formatter.field("dyn_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::Dyn>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.dyn_token)
+ });
+ formatter.field("bounds", Lite(&self.value.bounds));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeTuple> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeTuple");
+ formatter.field("elems", Lite(&self.value.elems));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::TypeVerbatim> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("TypeVerbatim");
+ formatter.field("tts", Lite(&self.value.tts));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UnOp> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::UnOp::Deref(_v0) => {
+ let mut formatter = formatter.debug_tuple("Deref");
+ formatter.finish()
+ }
+ syn::UnOp::Not(_v0) => {
+ let mut formatter = formatter.debug_tuple("Not");
+ formatter.finish()
+ }
+ syn::UnOp::Neg(_v0) => {
+ let mut formatter = formatter.debug_tuple("Neg");
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::UseGlob> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("UseGlob");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UseGroup> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("UseGroup");
+ formatter.field("items", Lite(&self.value.items));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UseName> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("UseName");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UsePath> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("UsePath");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("tree", Lite(&self.value.tree));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UseRename> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("UseRename");
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("rename", Lite(&self.value.rename));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::UseTree> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::UseTree::Path(_v0) => {
+ let mut formatter = formatter.debug_tuple("Path");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::UseTree::Name(_v0) => {
+ let mut formatter = formatter.debug_tuple("Name");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::UseTree::Rename(_v0) => {
+ let mut formatter = formatter.debug_tuple("Rename");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::UseTree::Glob(_v0) => {
+ let mut formatter = formatter.debug_tuple("Glob");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::UseTree::Group(_v0) => {
+ let mut formatter = formatter.debug_tuple("Group");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
+impl Debug for Lite<syn::Variant> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("Variant");
+ formatter.field("attrs", Lite(&self.value.attrs));
+ formatter.field("ident", Lite(&self.value.ident));
+ formatter.field("fields", Lite(&self.value.fields));
+ formatter.field("discriminant", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<(syn::token::Eq, syn::Expr)>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ formatter.write_str("(")?;
+ Debug::fmt(Lite(&_val.1), formatter)?;
+ formatter.write_str(")")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.discriminant)
+ });
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::VisCrate> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("VisCrate");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::VisPublic> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("VisPublic");
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::VisRestricted> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("VisRestricted");
+ formatter.field("in_token", {
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<syn::token::In>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(_val) => {
+ formatter.write_str("Some")?;
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(&self.value.in_token)
+ });
+ formatter.field("path", Lite(&self.value.path));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::Visibility> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::Visibility::Public(_v0) => {
+ let mut formatter = formatter.debug_tuple("Public");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Visibility::Crate(_v0) => {
+ let mut formatter = formatter.debug_tuple("Crate");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Visibility::Restricted(_v0) => {
+ let mut formatter = formatter.debug_tuple("Restricted");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::Visibility::Inherited => formatter.write_str("Inherited"),
+ }
+ }
+}
+impl Debug for Lite<syn::WhereClause> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ let mut formatter = formatter.debug_struct("WhereClause");
+ formatter.field("predicates", Lite(&self.value.predicates));
+ formatter.finish()
+ }
+}
+impl Debug for Lite<syn::WherePredicate> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.value {
+ syn::WherePredicate::Type(_v0) => {
+ let mut formatter = formatter.debug_tuple("Type");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::WherePredicate::Lifetime(_v0) => {
+ let mut formatter = formatter.debug_tuple("Lifetime");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ syn::WherePredicate::Eq(_v0) => {
+ let mut formatter = formatter.debug_tuple("Eq");
+ formatter.field(Lite(_v0));
+ formatter.finish()
+ }
+ }
+ }
+}
diff --git a/tests/debug/mod.rs b/tests/debug/mod.rs
new file mode 100644
index 0000000..781149b
--- /dev/null
+++ b/tests/debug/mod.rs
@@ -0,0 +1,104 @@
+extern crate proc_macro2;
+extern crate ref_cast;
+
+mod gen;
+
+use self::proc_macro2::{Ident, Literal, TokenStream};
+use self::ref_cast::RefCast;
+use std::fmt::{self, Debug};
+use std::ops::Deref;
+use syn::punctuated::Punctuated;
+
+#[derive(RefCast)]
+#[repr(transparent)]
+pub struct Lite<T: ?Sized> {
+ value: T,
+}
+
+#[allow(non_snake_case)]
+pub fn Lite<T: ?Sized>(value: &T) -> &Lite<T> {
+ Lite::ref_cast(value)
+}
+
+impl<T: ?Sized> Deref for Lite<T> {
+ type Target = T;
+
+ fn deref(&self) -> &Self::Target {
+ &self.value
+ }
+}
+
+impl Debug for Lite<bool> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{}", self.value)
+ }
+}
+
+impl Debug for Lite<u32> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{}", self.value)
+ }
+}
+
+impl Debug for Lite<usize> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{}", self.value)
+ }
+}
+
+impl Debug for Lite<String> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value)
+ }
+}
+
+impl Debug for Lite<Ident> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{:?}", self.value.to_string())
+ }
+}
+
+impl Debug for Lite<Literal> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "{}", self.value)
+ }
+}
+
+impl Debug for Lite<TokenStream> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ write!(formatter, "`{}`", self.value)
+ }
+}
+
+impl<T> Debug for Lite<Box<T>>
+where
+ Lite<T>: Debug,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ Debug::fmt(Lite(&*self.value), formatter)
+ }
+}
+
+impl<T> Debug for Lite<Vec<T>>
+where
+ Lite<T>: Debug,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter
+ .debug_list()
+ .entries(self.value.iter().map(Lite))
+ .finish()
+ }
+}
+
+impl<T, P> Debug for Lite<Punctuated<T, P>>
+where
+ Lite<T>: Debug,
+{
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ formatter
+ .debug_list()
+ .entries(self.value.iter().map(Lite))
+ .finish()
+ }
+}