Generate debug impls more appropriate for inline snapshot
diff --git a/Cargo.toml b/Cargo.toml
index c68d3b0..ee631b4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,6 +38,7 @@
[dev-dependencies]
insta = "0.8"
rayon = "1.0"
+ref-cast = "0.2"
regex = "1.0"
termcolor = "1.0"
walkdir = "2.1"
diff --git a/codegen/src/debug.rs b/codegen/src/debug.rs
new file mode 100644
index 0000000..e9908a3
--- /dev/null
+++ b/codegen/src/debug.rs
@@ -0,0 +1,205 @@
+use crate::error::Result;
+use crate::file;
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::quote;
+use syn::Index;
+use syn_codegen::{Data, Definitions, Node, Type};
+
+const DEBUG_SRC: &str = "../tests/debug/gen.rs";
+
+fn rust_type(ty: &Type) -> TokenStream {
+ match ty {
+ Type::Syn(ty) => {
+ let ident = Ident::new(ty, Span::call_site());
+ quote!(syn::#ident)
+ }
+ Type::Std(ty) => {
+ let ident = Ident::new(ty, Span::call_site());
+ quote!(#ident)
+ }
+ Type::Ext(ty) => {
+ let ident = Ident::new(ty, Span::call_site());
+ quote!(proc_macro2::#ident)
+ }
+ Type::Token(ty) | Type::Group(ty) => {
+ let ident = Ident::new(ty, Span::call_site());
+ quote!(syn::token::#ident)
+ }
+ Type::Punctuated(ty) => {
+ let element = rust_type(&ty.element);
+ let punct = Ident::new(&ty.punct, Span::call_site());
+ quote!(syn::punctuated::Punctuated<#element, #punct>)
+ }
+ Type::Option(ty) => {
+ let inner = rust_type(ty);
+ quote!(Option<#inner>)
+ }
+ Type::Box(ty) => {
+ let inner = rust_type(ty);
+ quote!(Box<#inner>)
+ }
+ Type::Vec(ty) => {
+ let inner = rust_type(ty);
+ quote!(Vec<#inner>)
+ }
+ Type::Tuple(ty) => {
+ let inner = ty.iter().map(rust_type);
+ quote!((#(#inner,)*))
+ }
+ }
+}
+
+fn is_printable(ty: &Type) -> bool {
+ match ty {
+ Type::Ext(name) => name != "Span",
+ Type::Box(ty) => is_printable(ty),
+ Type::Tuple(ty) => ty.iter().any(is_printable),
+ Type::Token(_) | Type::Group(_) => false,
+ Type::Syn(_) | Type::Std(_) | Type::Punctuated(_) | Type::Option(_) | Type::Vec(_) => true,
+ }
+}
+
+fn format_field(val: &TokenStream, ty: &Type) -> Option<TokenStream> {
+ if !is_printable(ty) {
+ return None;
+ }
+ let format = match ty {
+ Type::Option(ty) => {
+ let inner = quote!(_val);
+ let format = format_field(&inner, ty).map(|format| {
+ quote! {
+ formatter.write_str("(")?;
+ Debug::fmt(#format, formatter)?;
+ formatter.write_str(")")?;
+ }
+ });
+ let ty = rust_type(ty);
+ quote!({
+ #[derive(RefCast)]
+ #[repr(transparent)]
+ struct Print(Option<#ty>);
+ impl Debug for Print {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ match &self.0 {
+ Some(#inner) => {
+ formatter.write_str("Some")?;
+ #format
+ Ok(())
+ }
+ None => formatter.write_str("None"),
+ }
+ }
+ }
+ Print::ref_cast(#val)
+ })
+ }
+ Type::Tuple(ty) => {
+ let printable: Vec<TokenStream> = ty
+ .iter()
+ .enumerate()
+ .filter_map(|(i, ty)| {
+ let index = Index::from(i);
+ let val = quote!(&#val.#index);
+ format_field(&val, ty)
+ })
+ .collect();
+ if printable.len() == 1 {
+ printable.into_iter().next().unwrap()
+ } else {
+ quote! {
+ &(#(#printable),*)
+ }
+ }
+ }
+ _ => quote! { Lite(#val) },
+ };
+ Some(format)
+}
+
+fn expand_impl(node: &Node) -> TokenStream {
+ let name = &node.ident;
+ let ident = Ident::new(&node.ident, Span::call_site());
+
+ let body = match &node.data {
+ Data::Enum(variants) => {
+ let arms = variants.iter().map(|(v, fields)| {
+ let variant = Ident::new(v, Span::call_site());
+ if fields.is_empty() {
+ quote! {
+ syn::#ident::#variant => formatter.write_str(#v),
+ }
+ } else {
+ let pats = (0..fields.len())
+ .map(|i| Ident::new(&format!("_v{}", i), Span::call_site()));
+ let fields = fields.iter().enumerate().filter_map(|(i, ty)| {
+ let index = Ident::new(&format!("_v{}", i), Span::call_site());
+ let val = quote!(#index);
+ let format = format_field(&val, ty)?;
+ Some(quote! {
+ formatter.field(#format);
+ })
+ });
+ quote! {
+ syn::#ident::#variant(#(#pats),*) => {
+ let mut formatter = formatter.debug_tuple(#v);
+ #(#fields)*
+ formatter.finish()
+ }
+ }
+ }
+ });
+ quote! {
+ match &self.value {
+ #(#arms)*
+ }
+ }
+ }
+ Data::Struct(fields) => {
+ let fields = fields.iter().filter_map(|(f, ty)| {
+ let ident = Ident::new(f, Span::call_site());
+ let val = quote!(&self.value.#ident);
+ let format = format_field(&val, ty)?;
+ Some(quote! {
+ formatter.field(#f, #format);
+ })
+ });
+ quote! {
+ let mut formatter = formatter.debug_struct(#name);
+ #(#fields)*
+ formatter.finish()
+ }
+ }
+ Data::Private => {
+ quote! {
+ write!(formatter, "{:?}", self.value())
+ }
+ }
+ };
+
+ quote! {
+ impl Debug for Lite<syn::#ident> {
+ fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+ #body
+ }
+ }
+ }
+}
+
+pub fn generate(defs: &Definitions) -> Result<()> {
+ let mut impls = TokenStream::new();
+ for node in &defs.types {
+ impls.extend(expand_impl(node));
+ }
+
+ file::write(
+ DEBUG_SRC,
+ quote! {
+ use super::{Lite, RefCast};
+ use std::fmt::{self, Debug};
+
+ #impls
+ },
+ )?;
+
+ Ok(())
+}
diff --git a/codegen/src/main.rs b/codegen/src/main.rs
index 3e27e1e..3dc7383 100644
--- a/codegen/src/main.rs
+++ b/codegen/src/main.rs
@@ -12,6 +12,7 @@
#![recursion_limit = "128"]
#![allow(clippy::needless_pass_by_value)]
+mod debug;
mod error;
mod file;
mod fold;
@@ -40,5 +41,6 @@
fold::generate(&defs)?;
visit::generate(&defs)?;
visit_mut::generate(&defs)?;
+ debug::generate(&defs)?;
Ok(())
}
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()
+ }
+}
diff --git a/tests/macros/mod.rs b/tests/macros/mod.rs
index d53009b..a83be16 100644
--- a/tests/macros/mod.rs
+++ b/tests/macros/mod.rs
@@ -1,5 +1,8 @@
extern crate proc_macro2;
+#[path = "../debug/mod.rs"]
+pub mod debug;
+
use syn;
use syn::parse::{Parse, Result};
@@ -43,7 +46,8 @@
}};
(($($expr:tt)*) as $t:ty, @$snapshot:literal) => {{
let syntax_tree = ::macros::Tokens::parse::<$t>($($expr)*).unwrap();
- insta::assert_debug_snapshot_matches!(syntax_tree, @$snapshot);
+ let debug = crate::macros::debug::Lite(&syntax_tree);
+ insta::assert_debug_snapshot_matches!(debug, @$snapshot);
syntax_tree
}};
(($($expr:tt)*)) => {{
@@ -53,7 +57,8 @@
}};
(($($expr:tt)*) , @$snapshot:literal) => {{
let syntax_tree = $($expr)*;
- insta::assert_debug_snapshot_matches!(syntax_tree, @$snapshot);
+ let debug = crate::macros::debug::Lite(&syntax_tree);
+ insta::assert_debug_snapshot_matches!(debug, @$snapshot);
syntax_tree
}};
(($($expr:tt)*) $next:tt $($rest:tt)*) => {
diff --git a/tests/test_derive_input.rs b/tests/test_derive_input.rs
index 46b2845..a81ce62 100644
--- a/tests/test_derive_input.rs
+++ b/tests/test_derive_input.rs
@@ -19,9 +19,7 @@
⋮DeriveInput {
⋮ attrs: [],
⋮ vis: Inherited,
- ⋮ ident: Ident(
- ⋮ Unit,
- ⋮ ),
+ ⋮ ident: "Unit",
⋮ generics: Generics {
⋮ lt_token: None,
⋮ params: [],
@@ -30,11 +28,8 @@
⋮ },
⋮ data: Struct(
⋮ DataStruct {
- ⋮ struct_token: Struct,
⋮ fields: Unit,
- ⋮ semi_token: Some(
- ⋮ Semi,
- ⋮ ),
+ ⋮ semi_token: Some,
⋮ },
⋮ ),
⋮}
@@ -56,47 +51,23 @@
⋮DeriveInput {
⋮ attrs: [
⋮ Attribute {
- ⋮ pound_token: Pound,
⋮ style: Outer,
- ⋮ bracket_token: Bracket,
⋮ path: Path {
⋮ leading_colon: None,
⋮ segments: [
⋮ PathSegment {
- ⋮ ident: Ident(
- ⋮ derive,
- ⋮ ),
+ ⋮ ident: "derive",
⋮ arguments: None,
⋮ },
⋮ ],
⋮ },
- ⋮ tts: TokenStream [
- ⋮ Group {
- ⋮ delimiter: Parenthesis,
- ⋮ stream: TokenStream [
- ⋮ Ident {
- ⋮ sym: Debug,
- ⋮ },
- ⋮ Punct {
- ⋮ op: ',',
- ⋮ spacing: Alone,
- ⋮ },
- ⋮ Ident {
- ⋮ sym: Clone,
- ⋮ },
- ⋮ ],
- ⋮ },
- ⋮ ],
+ ⋮ tts: `( Debug , Clone )`,
⋮ },
⋮ ],
⋮ vis: Public(
- ⋮ VisPublic {
- ⋮ pub_token: Pub,
- ⋮ },
+ ⋮ VisPublic,
⋮ ),
- ⋮ ident: Ident(
- ⋮ Item,
- ⋮ ),
+ ⋮ ident: "Item",
⋮ generics: Generics {
⋮ lt_token: None,
⋮ params: [],
@@ -105,26 +76,16 @@
⋮ },
⋮ data: Struct(
⋮ DataStruct {
- ⋮ struct_token: Struct,
⋮ fields: Named(
⋮ FieldsNamed {
- ⋮ brace_token: Brace,
⋮ named: [
⋮ Field {
⋮ attrs: [],
⋮ vis: Public(
- ⋮ VisPublic {
- ⋮ pub_token: Pub,
- ⋮ },
+ ⋮ VisPublic,
⋮ ),
- ⋮ ident: Some(
- ⋮ Ident(
- ⋮ ident,
- ⋮ ),
- ⋮ ),
- ⋮ colon_token: Some(
- ⋮ Colon,
- ⋮ ),
+ ⋮ ident: Some("ident"),
+ ⋮ colon_token: Some,
⋮ ty: Path(
⋮ TypePath {
⋮ qself: None,
@@ -132,9 +93,7 @@
⋮ leading_colon: None,
⋮ segments: [
⋮ PathSegment {
- ⋮ ident: Ident(
- ⋮ Ident,
- ⋮ ),
+ ⋮ ident: "Ident",
⋮ arguments: None,
⋮ },
⋮ ],
@@ -142,22 +101,13 @@
⋮ },
⋮ ),
⋮ },
- ⋮ Comma,
⋮ Field {
⋮ attrs: [],
⋮ vis: Public(
- ⋮ VisPublic {
- ⋮ pub_token: Pub,
- ⋮ },
+ ⋮ VisPublic,
⋮ ),
- ⋮ ident: Some(
- ⋮ Ident(
- ⋮ attrs,
- ⋮ ),
- ⋮ ),
- ⋮ colon_token: Some(
- ⋮ Colon,
- ⋮ ),
+ ⋮ ident: Some("attrs"),
+ ⋮ colon_token: Some,
⋮ ty: Path(
⋮ TypePath {
⋮ qself: None,
@@ -165,13 +115,10 @@
⋮ leading_colon: None,
⋮ segments: [
⋮ PathSegment {
- ⋮ ident: Ident(
- ⋮ Vec,
- ⋮ ),
+ ⋮ ident: "Vec",
⋮ arguments: AngleBracketed(
⋮ AngleBracketedGenericArguments {
⋮ colon2_token: None,
- ⋮ lt_token: Lt,
⋮ args: [
⋮ Type(
⋮ Path(
@@ -181,9 +128,7 @@
⋮ leading_colon: None,
⋮ segments: [
⋮ PathSegment {
- ⋮ ident: Ident(
- ⋮ Attribute,
- ⋮ ),
+ ⋮ ident: "Attribute",
⋮ arguments: None,
⋮ },
⋮ ],
@@ -192,7 +137,6 @@
⋮ ),
⋮ ),
⋮ ],
- ⋮ gt_token: Gt,
⋮ },
⋮ ),
⋮ },
@@ -214,24 +158,16 @@
snapshot!(actual.attrs[0].interpret_meta().unwrap(), @r###"
⋮List(
⋮ MetaList {
- ⋮ ident: Ident(
- ⋮ derive,
- ⋮ ),
- ⋮ paren_token: Paren,
+ ⋮ ident: "derive",
⋮ nested: [
⋮ Meta(
⋮ Word(
- ⋮ Ident(
- ⋮ Debug,
- ⋮ ),
+ ⋮ "Debug",
⋮ ),
⋮ ),
- ⋮ Comma,
⋮ Meta(
⋮ Word(
- ⋮ Ident(
- ⋮ Clone,
- ⋮ ),
+ ⋮ "Clone",
⋮ ),
⋮ ),
⋮ ],