blob: 779549661c621c7b3abf4449c05a0816519e13e1 [file] [log] [blame]
David Tolnay3c3c7d12019-05-08 14:54:12 -07001use crate::error::Result;
2use crate::file;
3use proc_macro2::{Ident, Span, TokenStream};
4use quote::quote;
5use syn::Index;
6use syn_codegen::{Data, Definitions, Node, Type};
7
8const DEBUG_SRC: &str = "../tests/debug/gen.rs";
9
10fn 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
52fn 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
62fn 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 Tolnay5302f0e2019-05-08 23:26:18 -0700119fn 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
129fn 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
138fn expand_impl_body(defs: &Definitions, node: &Node, name: &str) -> TokenStream {
David Tolnay3c3c7d12019-05-08 14:54:12 -0700139 let ident = Ident::new(&node.ident, Span::call_site());
140
David Tolnay5302f0e2019-05-08 23:26:18 -0700141 match &node.data {
David Tolnay3c3c7d12019-05-08 14:54:12 -0700142 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 Tolnay5302f0e2019-05-08 23:26:18 -0700149 } 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 Tolnay3c3c7d12019-05-08 14:54:12 -0700157 } 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 Tolnay5302f0e2019-05-08 23:26:18 -0700178 match _val {
David Tolnay3c3c7d12019-05-08 14:54:12 -0700179 #(#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 Tolnay644246b2019-05-08 23:02:46 -0700186 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 Tolnay5302f0e2019-05-08 23:26:18 -0700198 if let Some(val) = &_val.#ident {
David Tolnay644246b2019-05-08 23:02:46 -0700199 #[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 Tolnay5302f0e2019-05-08 23:26:18 -0700213 let val = quote!(&_val.#ident);
David Tolnay644246b2019-05-08 23:02:46 -0700214 let format = format_field(&val, ty)?;
David Tolnaycaac6272019-05-09 11:26:37 -0700215 let mut call = quote! {
David Tolnay644246b2019-05-08 23:02:46 -0700216 formatter.field(#f, #format);
David Tolnaycaac6272019-05-09 11:26:37 -0700217 };
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 Tolnay644246b2019-05-08 23:02:46 -0700226 }
David Tolnay3c3c7d12019-05-08 14:54:12 -0700227 });
228 quote! {
229 let mut formatter = formatter.debug_struct(#name);
230 #(#fields)*
231 formatter.finish()
232 }
233 }
234 Data::Private => {
235 quote! {
David Tolnay5302f0e2019-05-08 23:26:18 -0700236 write!(formatter, "{:?}", _val.value())
David Tolnay3c3c7d12019-05-08 14:54:12 -0700237 }
238 }
David Tolnay5302f0e2019-05-08 23:26:18 -0700239 }
240}
241
242fn 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 Tolnay3c3c7d12019-05-08 14:54:12 -0700245
246 quote! {
247 impl Debug for Lite<syn::#ident> {
248 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
David Tolnay5302f0e2019-05-08 23:26:18 -0700249 let _val = &self.value;
David Tolnay3c3c7d12019-05-08 14:54:12 -0700250 #body
251 }
252 }
253 }
254}
255
256pub fn generate(defs: &Definitions) -> Result<()> {
257 let mut impls = TokenStream::new();
258 for node in &defs.types {
David Tolnay5302f0e2019-05-08 23:26:18 -0700259 impls.extend(expand_impl(&defs, node));
David Tolnay3c3c7d12019-05-08 14:54:12 -0700260 }
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}