David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 1 | use crate::error::Result; |
| 2 | use crate::file; |
| 3 | use proc_macro2::{Ident, Span, TokenStream}; |
| 4 | use quote::quote; |
| 5 | use syn::Index; |
| 6 | use syn_codegen::{Data, Definitions, Node, Type}; |
| 7 | |
| 8 | const DEBUG_SRC: &str = "../tests/debug/gen.rs"; |
| 9 | |
| 10 | fn rust_type(ty: &Type) -> TokenStream { |
| 11 | match ty { |
| 12 | Type::Syn(ty) => { |
| 13 | let ident = Ident::new(ty, Span::call_site()); |
| 14 | quote!(syn::#ident) |
| 15 | } |
| 16 | Type::Std(ty) => { |
| 17 | let ident = Ident::new(ty, Span::call_site()); |
| 18 | quote!(#ident) |
| 19 | } |
| 20 | Type::Ext(ty) => { |
| 21 | let ident = Ident::new(ty, Span::call_site()); |
| 22 | quote!(proc_macro2::#ident) |
| 23 | } |
| 24 | Type::Token(ty) | Type::Group(ty) => { |
| 25 | let ident = Ident::new(ty, Span::call_site()); |
| 26 | quote!(syn::token::#ident) |
| 27 | } |
| 28 | Type::Punctuated(ty) => { |
| 29 | let element = rust_type(&ty.element); |
| 30 | let punct = Ident::new(&ty.punct, Span::call_site()); |
| 31 | quote!(syn::punctuated::Punctuated<#element, #punct>) |
| 32 | } |
| 33 | Type::Option(ty) => { |
| 34 | let inner = rust_type(ty); |
| 35 | quote!(Option<#inner>) |
| 36 | } |
| 37 | Type::Box(ty) => { |
| 38 | let inner = rust_type(ty); |
| 39 | quote!(Box<#inner>) |
| 40 | } |
| 41 | Type::Vec(ty) => { |
| 42 | let inner = rust_type(ty); |
| 43 | quote!(Vec<#inner>) |
| 44 | } |
| 45 | Type::Tuple(ty) => { |
| 46 | let inner = ty.iter().map(rust_type); |
| 47 | quote!((#(#inner,)*)) |
| 48 | } |
| 49 | } |
| 50 | } |
| 51 | |
| 52 | fn is_printable(ty: &Type) -> bool { |
| 53 | match ty { |
| 54 | Type::Ext(name) => name != "Span", |
| 55 | Type::Box(ty) => is_printable(ty), |
| 56 | Type::Tuple(ty) => ty.iter().any(is_printable), |
| 57 | Type::Token(_) | Type::Group(_) => false, |
| 58 | Type::Syn(_) | Type::Std(_) | Type::Punctuated(_) | Type::Option(_) | Type::Vec(_) => true, |
| 59 | } |
| 60 | } |
| 61 | |
| 62 | fn format_field(val: &TokenStream, ty: &Type) -> Option<TokenStream> { |
| 63 | if !is_printable(ty) { |
| 64 | return None; |
| 65 | } |
| 66 | let format = match ty { |
| 67 | Type::Option(ty) => { |
| 68 | let inner = quote!(_val); |
| 69 | let format = format_field(&inner, ty).map(|format| { |
| 70 | quote! { |
| 71 | formatter.write_str("(")?; |
| 72 | Debug::fmt(#format, formatter)?; |
| 73 | formatter.write_str(")")?; |
| 74 | } |
| 75 | }); |
| 76 | let ty = rust_type(ty); |
| 77 | quote!({ |
| 78 | #[derive(RefCast)] |
| 79 | #[repr(transparent)] |
| 80 | struct Print(Option<#ty>); |
| 81 | impl Debug for Print { |
| 82 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 83 | match &self.0 { |
| 84 | Some(#inner) => { |
| 85 | formatter.write_str("Some")?; |
| 86 | #format |
| 87 | Ok(()) |
| 88 | } |
| 89 | None => formatter.write_str("None"), |
| 90 | } |
| 91 | } |
| 92 | } |
| 93 | Print::ref_cast(#val) |
| 94 | }) |
| 95 | } |
| 96 | Type::Tuple(ty) => { |
| 97 | let printable: Vec<TokenStream> = ty |
| 98 | .iter() |
| 99 | .enumerate() |
| 100 | .filter_map(|(i, ty)| { |
| 101 | let index = Index::from(i); |
| 102 | let val = quote!(&#val.#index); |
| 103 | format_field(&val, ty) |
| 104 | }) |
| 105 | .collect(); |
| 106 | if printable.len() == 1 { |
| 107 | printable.into_iter().next().unwrap() |
| 108 | } else { |
| 109 | quote! { |
| 110 | &(#(#printable),*) |
| 111 | } |
| 112 | } |
| 113 | } |
| 114 | _ => quote! { Lite(#val) }, |
| 115 | }; |
| 116 | Some(format) |
| 117 | } |
| 118 | |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 119 | fn syntax_tree_enum<'a>(outer: &str, inner: &str, fields: &'a [Type]) -> Option<&'a str> { |
| 120 | if fields.len() != 1 { |
| 121 | return None; |
| 122 | } |
| 123 | match &fields[0] { |
| 124 | Type::Syn(ty) if outer.to_owned() + inner == *ty => Some(ty), |
| 125 | _ => None |
| 126 | } |
| 127 | } |
| 128 | |
| 129 | fn lookup<'a>(defs: &'a Definitions, name: &str) -> &'a Node { |
| 130 | for node in &defs.types { |
| 131 | if node.ident == name { |
| 132 | return node; |
| 133 | } |
| 134 | } |
| 135 | panic!("not found: {}", name) |
| 136 | } |
| 137 | |
| 138 | fn expand_impl_body(defs: &Definitions, node: &Node, name: &str) -> TokenStream { |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 139 | let ident = Ident::new(&node.ident, Span::call_site()); |
| 140 | |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 141 | match &node.data { |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 142 | Data::Enum(variants) => { |
| 143 | let arms = variants.iter().map(|(v, fields)| { |
| 144 | let variant = Ident::new(v, Span::call_site()); |
| 145 | if fields.is_empty() { |
| 146 | quote! { |
| 147 | syn::#ident::#variant => formatter.write_str(#v), |
| 148 | } |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 149 | } else if let Some(inner) = syntax_tree_enum(name, v, fields) { |
| 150 | let path = format!("{}::{}", name, v); |
| 151 | let format = expand_impl_body(defs, lookup(defs, inner), &path); |
| 152 | quote! { |
| 153 | syn::#ident::#variant(_val) => { |
| 154 | #format |
| 155 | } |
| 156 | } |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 157 | } else { |
| 158 | let pats = (0..fields.len()) |
| 159 | .map(|i| Ident::new(&format!("_v{}", i), Span::call_site())); |
| 160 | let fields = fields.iter().enumerate().filter_map(|(i, ty)| { |
| 161 | let index = Ident::new(&format!("_v{}", i), Span::call_site()); |
| 162 | let val = quote!(#index); |
| 163 | let format = format_field(&val, ty)?; |
| 164 | Some(quote! { |
| 165 | formatter.field(#format); |
| 166 | }) |
| 167 | }); |
| 168 | quote! { |
| 169 | syn::#ident::#variant(#(#pats),*) => { |
| 170 | let mut formatter = formatter.debug_tuple(#v); |
| 171 | #(#fields)* |
| 172 | formatter.finish() |
| 173 | } |
| 174 | } |
| 175 | } |
| 176 | }); |
| 177 | quote! { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 178 | match _val { |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 179 | #(#arms)* |
| 180 | } |
| 181 | } |
| 182 | } |
| 183 | Data::Struct(fields) => { |
| 184 | let fields = fields.iter().filter_map(|(f, ty)| { |
| 185 | let ident = Ident::new(f, Span::call_site()); |
David Tolnay | 644246b | 2019-05-08 23:02:46 -0700 | [diff] [blame] | 186 | if let Type::Option(ty) = ty { |
| 187 | let inner = quote!(_val); |
| 188 | let format = format_field(&inner, ty).map(|format| { |
| 189 | quote! { |
| 190 | let #inner = &self.0; |
| 191 | formatter.write_str("(")?; |
| 192 | Debug::fmt(#format, formatter)?; |
| 193 | formatter.write_str(")")?; |
| 194 | } |
| 195 | }); |
| 196 | let ty = rust_type(ty); |
| 197 | Some(quote! { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 198 | if let Some(val) = &_val.#ident { |
David Tolnay | 644246b | 2019-05-08 23:02:46 -0700 | [diff] [blame] | 199 | #[derive(RefCast)] |
| 200 | #[repr(transparent)] |
| 201 | struct Print(#ty); |
| 202 | impl Debug for Print { |
| 203 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| 204 | formatter.write_str("Some")?; |
| 205 | #format |
| 206 | Ok(()) |
| 207 | } |
| 208 | } |
| 209 | formatter.field(#f, Print::ref_cast(val)); |
| 210 | } |
| 211 | }) |
| 212 | } else { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 213 | let val = quote!(&_val.#ident); |
David Tolnay | 644246b | 2019-05-08 23:02:46 -0700 | [diff] [blame] | 214 | let format = format_field(&val, ty)?; |
David Tolnay | caac627 | 2019-05-09 11:26:37 -0700 | [diff] [blame^] | 215 | let mut call = quote! { |
David Tolnay | 644246b | 2019-05-08 23:02:46 -0700 | [diff] [blame] | 216 | formatter.field(#f, #format); |
David Tolnay | caac627 | 2019-05-09 11:26:37 -0700 | [diff] [blame^] | 217 | }; |
| 218 | if let Type::Vec(_) | Type::Punctuated(_) = ty { |
| 219 | call = quote! { |
| 220 | if !_val.#ident.is_empty() { |
| 221 | #call |
| 222 | } |
| 223 | }; |
| 224 | } |
| 225 | Some(call) |
David Tolnay | 644246b | 2019-05-08 23:02:46 -0700 | [diff] [blame] | 226 | } |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 227 | }); |
| 228 | quote! { |
| 229 | let mut formatter = formatter.debug_struct(#name); |
| 230 | #(#fields)* |
| 231 | formatter.finish() |
| 232 | } |
| 233 | } |
| 234 | Data::Private => { |
| 235 | quote! { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 236 | write!(formatter, "{:?}", _val.value()) |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 237 | } |
| 238 | } |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 239 | } |
| 240 | } |
| 241 | |
| 242 | fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream { |
| 243 | let ident = Ident::new(&node.ident, Span::call_site()); |
| 244 | let body = expand_impl_body(defs, node, &node.ident); |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 245 | |
| 246 | quote! { |
| 247 | impl Debug for Lite<syn::#ident> { |
| 248 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 249 | let _val = &self.value; |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 250 | #body |
| 251 | } |
| 252 | } |
| 253 | } |
| 254 | } |
| 255 | |
| 256 | pub fn generate(defs: &Definitions) -> Result<()> { |
| 257 | let mut impls = TokenStream::new(); |
| 258 | for node in &defs.types { |
David Tolnay | 5302f0e | 2019-05-08 23:26:18 -0700 | [diff] [blame] | 259 | impls.extend(expand_impl(&defs, node)); |
David Tolnay | 3c3c7d1 | 2019-05-08 14:54:12 -0700 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | file::write( |
| 263 | DEBUG_SRC, |
| 264 | quote! { |
| 265 | use super::{Lite, RefCast}; |
| 266 | use std::fmt::{self, Debug}; |
| 267 | |
| 268 | #impls |
| 269 | }, |
| 270 | )?; |
| 271 | |
| 272 | Ok(()) |
| 273 | } |