git.delta.rocks / jrsonnet / refs/commits / f0c8338d487d

1use crate::names::Names;2use crate::{extract_type_from_option, kw, parse_attr, type_is_path};3use proc_macro2::TokenStream;4use quote::quote;5use syn::parse::{Parse, ParseStream};6use syn::spanned::Spanned as _;7use syn::{parenthesized, token, DeriveInput, Error, Ident, LitStr, Result, Token, Type};89#[derive(Default)]10#[allow(clippy::struct_excessive_bools)]11struct TypedAttr {12	rename: Option<String>,13	aliases: Vec<String>,14	flatten: bool,15	/// flatten(ok) strategy for flattened optionals16	/// field would be None in case of any parsing error (as in serde)17	flatten_ok: bool,18	// Should it be `field+:` instead of `field:`19	add: bool,20	// Should it be `field::` instead of `field:`21	hide: bool,22}23impl Parse for TypedAttr {24	fn parse(input: ParseStream) -> syn::Result<Self> {25		let mut out = Self::default();26		loop {27			let lookahead = input.lookahead1();28			if lookahead.peek(kw::rename) {29				input.parse::<kw::rename>()?;30				input.parse::<Token![=]>()?;31				let name = input.parse::<LitStr>()?;32				if out.rename.is_some() {33					return Err(Error::new(34						name.span(),35						"rename attribute may only be specified once",36					));37				}38				out.rename = Some(name.value());39			} else if lookahead.peek(kw::alias) {40				input.parse::<kw::alias>()?;41				input.parse::<Token![=]>()?;42				let alias = input.parse::<LitStr>()?;43				out.aliases.push(alias.value());44			} else if lookahead.peek(kw::flatten) {45				input.parse::<kw::flatten>()?;46				out.flatten = true;47				if input.peek(token::Paren) {48					let content;49					parenthesized!(content in input);50					let lookahead = content.lookahead1();51					if lookahead.peek(kw::ok) {52						content.parse::<kw::ok>()?;53						out.flatten_ok = true;54					} else {55						return Err(lookahead.error());56					}57				}58			} else if lookahead.peek(kw::add) {59				input.parse::<kw::add>()?;60				out.add = true;61			} else if lookahead.peek(kw::hide) {62				input.parse::<kw::hide>()?;63				out.hide = true;64			} else if input.is_empty() {65				break;66			} else {67				return Err(lookahead.error());68			}69			if input.peek(Token![,]) {70				input.parse::<Token![,]>()?;71			} else {72				break;73			}74		}75		Ok(out)76	}77}78struct TypedField {79	attr: TypedAttr,80	ident: Ident,81	ty: Type,82	is_option: bool,83	is_lazy: bool,84}85impl TypedField {86	fn parse(field: &syn::Field) -> Result<Self> {87		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();88		let Some(ident) = field.ident.clone() else {89			return Err(Error::new(90				field.span(),91				"this field should appear in output object, but it has no visible name",92			));93		};94		let (is_option, ty) = extract_type_from_option(&field.ty)?95			.map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));96		if is_option && attr.flatten {97			if !attr.flatten_ok {98				return Err(Error::new(99					field.span(),100					"strategy should be set when flattening Option",101				));102			}103		} else if attr.flatten_ok {104			return Err(Error::new(105				field.span(),106				"flatten(ok) is only useable on optional fields",107			));108		}109110		let is_lazy = type_is_path(&ty, "Thunk").is_some();111112		Ok(Self {113			attr,114			ident,115			ty,116			is_option,117			is_lazy,118		})119	}120	/// None if this field is flattened in jsonnet output121	fn name(&self) -> Option<String> {122		if self.attr.flatten {123			return None;124		}125		Some(126			self.attr127				.rename128				.clone()129				.unwrap_or_else(|| self.ident.to_string()),130		)131	}132133	fn expand_field(&self) -> Option<TokenStream> {134		if self.is_option {135			return None;136		}137		let name = self.name()?;138		let ty = &self.ty;139		Some(quote! {140			(#name, <#ty as Typed>::TYPE)141		})142	}143144	fn expand_parse(&self, names: &mut Names) -> TokenStream {145		if self.is_option {146			self.expand_parse_optional(names)147		} else {148			self.expand_parse_mandatory(names)149		}150	}151152	fn expand_parse_optional(&self, names: &mut Names) -> TokenStream {153		let ident = &self.ident;154		let ty = &self.ty;155156		// optional flatten is handled in same way as serde157		if self.attr.flatten {158			return quote! {159				#ident: <#ty as TypedObj>::parse(&obj).ok(),160			};161		}162163		let name = names.intern(self.name().unwrap());164		let aliases = self165			.attr166			.aliases167			.iter()168			.map(|name| names.intern(name))169			.collect::<Vec<_>>();170171		quote! {172			#ident: {173				let __value = if let Some(__v) = obj.get(__names[#name].clone())? {174					Some(__v)175				} #(else if let Some(__v) = obj.get(__names[#aliases].clone())? {176					Some(__v)177				})* else {178					None179				};180181				__value.map(<#ty as FromUntyped>::from_untyped).transpose()?182			},183		}184	}185186	fn expand_parse_mandatory(&self, names: &mut Names) -> TokenStream {187		let ident = &self.ident;188		let ty = &self.ty;189190		// optional flatten is handled in same way as serde191		if self.attr.flatten {192			return quote! {193				#ident: <#ty as TypedObj>::parse(&obj)?,194			};195		}196197		let name = self.name().unwrap();198		let aliases = &self.attr.aliases;199200		let error_text = if aliases.is_empty() {201			// clippy does not understand name variable usage in quote! macro202			#[allow(clippy::redundant_clone)]203			name.clone()204		} else {205			format!("{name} (alias {})", aliases.join(", "))206		};207208		let error_text = names.intern(error_text);209		let name = names.intern(name);210		let aliases = aliases.iter().map(|alias| names.intern(alias));211212		quote! {213			#ident: {214				let __value = if let Some(__v) = obj.get(__names[#name].clone())? {215					__v216				} #(else if let Some(__v) = obj.get(__names[#aliases].clone())? {217					__v218				})* else {219					return Err(ErrorKind::NoSuchField(__names[#error_text].clone(), vec![]).into());220				};221222				<#ty as FromUntyped>::from_untyped(__value)?223			},224		}225	}226227	fn expand_serialize(&self, names: &mut Names) -> TokenStream {228		let ident = &self.ident;229		let ty = &self.ty;230		self.name().map_or_else(231			|| {232				if self.is_option {233					quote! {234						if let Some(value) = self.#ident {235							<#ty as TypedObj>::serialize(value, out)?;236						}237					}238				} else {239					quote! {240						<#ty as TypedObj>::serialize(self.#ident, out)?;241					}242				}243			},244			|name| {245				let name = names.intern(name);246				let hide = if self.attr.hide {247					quote! {.hide()}248				} else {249					quote! {}250				};251				let add = if self.attr.add {252					quote! {.add()}253				} else {254					quote! {}255				};256				let value = if self.is_lazy {257					quote! {258						out.field(__names[#name].clone())259							#hide260							#add261							.try_thunk(<#ty as IntoUntyped>::into_lazy_untyped(value))?;262					}263				} else {264					quote! {265						out.field(__names[#name].clone())266							#hide267							#add268							.try_value(<#ty as IntoUntyped>::into_untyped(value)?)?;269					}270				};271				if self.is_option {272					quote! {273						if let Some(value) = self.#ident {274							#value275						}276					}277				} else {278					quote! {279						{280							let value = self.#ident;281							#value282						}283					}284				}285			},286		)287	}288}289290pub fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {291	let syn::Data::Struct(data) = &input.data else {292		return Err(Error::new(input.span(), "only structs supported"));293	};294295	let ident = &input.ident;296	let fields = data297		.fields298		.iter()299		.map(TypedField::parse)300		.collect::<Result<Vec<_>>>()?;301302	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();303304	let fields = fields305		.iter()306		.filter_map(TypedField::expand_field)307		.collect::<Vec<_>>();308	Ok(quote! {309		const _: () = {310			use ::jrsonnet_evaluator::typed::__typed_macro_prelude::*;311312			impl #impl_generics Typed for #ident #ty_generics #where_clause {313				const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[314					#(#fields,)*315				]);316			}317		};318	})319}320pub fn derive_into_untyped_inner(input: DeriveInput) -> Result<TokenStream> {321	let syn::Data::Struct(data) = &input.data else {322		return Err(Error::new(input.span(), "only structs supported"));323	};324325	let ident = &input.ident;326	let fields = data327		.fields328		.iter()329		.map(TypedField::parse)330		.collect::<Result<Vec<_>>>()?;331332	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();333334	let capacity = fields.len();335336	let mut names = Names::default();337338	let fields_serialize = fields339		.iter()340		.map(|f| f.expand_serialize(&mut names))341		.collect::<Vec<_>>();342343	let names_expanded = names.expand();344	Ok(quote! {345		const _: () = {346			use ::jrsonnet_evaluator::typed::__typed_macro_prelude::*;347348			impl #impl_generics IntoUntyped for #ident #ty_generics #where_clause {349				fn into_untyped(value: Self) -> JrResult<Val> {350					let mut out = ObjValueBuilder::with_capacity(#capacity);351					value.serialize(&mut out)?;352					Ok(Val::Obj(out.build()))353				}354			}355356			#names_expanded357358			impl #impl_generics SerializeTypedObj for #ident #ty_generics #where_clause {359				fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {360					NAMES.with(|__names| {361						#(#fields_serialize)*362363						Ok(())364					})365				}366			}367		};368	})369}370pub fn derive_from_untyped_inner(input: DeriveInput) -> Result<TokenStream> {371	let syn::Data::Struct(data) = &input.data else {372		return Err(Error::new(input.span(), "only structs supported"));373	};374375	let ident = &input.ident;376	let fields = data377		.fields378		.iter()379		.map(TypedField::parse)380		.collect::<Result<Vec<_>>>()?;381382	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();383384	let mut names = Names::default();385386	let fields_parse = fields387		.iter()388		.map(|f| f.expand_parse(&mut names))389		.collect::<Vec<_>>();390391	let names_expanded = names.expand();392	Ok(quote! {393		const _: () = {394			use ::jrsonnet_evaluator::typed::__typed_macro_prelude::*;395396			impl #impl_generics FromUntyped for #ident #ty_generics #where_clause {397				fn from_untyped(value: Val) -> JrResult<Self> {398					let obj = value.as_obj().expect("shape is correct");399					Self::parse(&obj)400				}401			}402403			#names_expanded404405			impl #impl_generics ParseTypedObj for #ident #ty_generics #where_clause {406				fn parse(obj: &ObjValue) -> JrResult<Self> {407					NAMES.with(|__names| Ok(Self {408						#(#fields_parse)*409					}))410				}411			}412		};413	})414}