git.delta.rocks / jrsonnet / refs/commits / 86671948a995

1use std::string::String;23use proc_macro2::TokenStream;4use quote::{quote, quote_spanned};5use syn::{6	parenthesized,7	parse::{Parse, ParseStream},8	parse_macro_input,9	punctuated::Punctuated,10	spanned::Spanned,11	token::{self, Comma},12	Attribute, DeriveInput, Error, Expr, ExprClosure, FnArg, GenericArgument, Ident, ItemFn,13	LitStr, Meta, Pat, Path, PathArguments, Result, ReturnType, Token, Type,14};1516fn try_parse_attr_noargs<I>(attrs: &[Attribute], ident: I) -> Result<bool>17where18	Ident: PartialEq<I>,19{20	let attrs = attrs21		.iter()22		.filter(|a| a.path().is_ident(&ident))23		.collect::<Vec<_>>();24	if attrs.len() > 1 {25		return Err(Error::new(26			attrs[1].span(),27			"this attribute may be specified only once",28		));29	} else if attrs.is_empty() {30		return Ok(false);31	}32	let attr = attrs[0];3334	match attr.meta {35		Meta::Path(_) => Ok(true),36		_ => Ok(false),37	}38}39fn parse_attr<A: Parse, I>(attrs: &[Attribute], ident: I) -> Result<Option<A>>40where41	Ident: PartialEq<I>,42{43	let attrs = attrs44		.iter()45		.filter(|a| a.path().is_ident(&ident))46		.collect::<Vec<_>>();47	if attrs.len() > 1 {48		return Err(Error::new(49			attrs[1].span(),50			"this attribute may be specified only once",51		));52	} else if attrs.is_empty() {53		return Ok(None);54	}55	let attr = attrs[0];56	let attr = attr.parse_args::<A>()?;5758	Ok(Some(attr))59}60fn remove_attr<I>(attrs: &mut Vec<Attribute>, ident: I)61where62	Ident: PartialEq<I>,63{64	attrs.retain(|a| !a.path().is_ident(&ident));65}6667fn path_is(path: &Path, needed: &str) -> bool {68	path.leading_colon.is_none()69		&& !path.segments.is_empty()70		&& path.segments.iter().last().unwrap().ident == needed71}7273fn type_is_path<'ty>(ty: &'ty Type, needed: &str) -> Option<&'ty PathArguments> {74	match ty {75		Type::Path(path) if path.qself.is_none() && path_is(&path.path, needed) => {76			let args = &path.path.segments.iter().last().unwrap().arguments;77			Some(args)78		}79		_ => None,80	}81}8283fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {84	let Some(args) = type_is_path(ty, "Option") else {85		return Ok(None);86	};87	// It should have only on angle-bracketed param ("<String>"):88	let PathArguments::AngleBracketed(params) = args else {89		return Err(Error::new(args.span(), "missing option generic"));90	};91	let generic_arg = params.args.iter().next().unwrap();92	// This argument must be a type:93	let GenericArgument::Type(ty) = generic_arg else {94		return Err(Error::new(95			generic_arg.span(),96			"option generic should be a type",97		));98	};99	Ok(Some(ty))100}101102struct Field {103	attrs: Vec<Attribute>,104	name: Ident,105	_colon: Token![:],106	ty: Type,107}108impl Parse for Field {109	fn parse(input: ParseStream) -> syn::Result<Self> {110		Ok(Self {111			attrs: input.call(Attribute::parse_outer)?,112			name: input.parse()?,113			_colon: input.parse()?,114			ty: input.parse()?,115		})116	}117}118119mod kw {120	syn::custom_keyword!(fields);121	syn::custom_keyword!(rename);122	syn::custom_keyword!(alias);123	syn::custom_keyword!(flatten);124	syn::custom_keyword!(add);125	syn::custom_keyword!(hide);126	syn::custom_keyword!(ok);127}128129struct BuiltinAttrs {130	fields: Vec<Field>,131}132impl Parse for BuiltinAttrs {133	fn parse(input: ParseStream) -> syn::Result<Self> {134		if input.is_empty() {135			return Ok(Self { fields: Vec::new() });136		}137		input.parse::<kw::fields>()?;138		let fields;139		parenthesized!(fields in input);140		let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;141		Ok(Self {142			fields: p.into_iter().collect(),143		})144	}145}146147enum Optionality {148	Required,149	Optional,150	Default(Expr),151	TypeDefault,152}153154#[allow(155	clippy::large_enum_variant,156	reason = "this macro is not that hot for it to matter"157)]158enum ArgInfo {159	Normal {160		ty: Box<Type>,161		optionality: Optionality,162		name: Option<String>,163		cfg_attrs: Vec<Attribute>,164	},165	Lazy {166		is_option: bool,167		name: Option<String>,168	},169	Context,170	Location,171	This,172}173174impl ArgInfo {175	fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {176		let FnArg::Typed(arg) = arg else {177			unreachable!()178		};179		let ident = match &arg.pat as &Pat {180			Pat::Ident(i) => Some(i.ident.clone()),181			_ => None,182		};183		let ty = &arg.ty;184		if type_is_path(ty, "Context").is_some() {185			return Ok(Self::Context);186		} else if type_is_path(ty, "CallLocation").is_some() {187			return Ok(Self::Location);188		} else if type_is_path(ty, "Thunk").is_some() {189			return Ok(Self::Lazy {190				is_option: false,191				name: ident.map(|v| v.to_string()),192			});193		}194195		match ty as &Type {196			Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),197			_ => {}198		}199200		let (optionality, ty) = if try_parse_attr_noargs(&mut arg.attrs, "default")? {201			remove_attr(&mut arg.attrs, "default");202			(Optionality::TypeDefault, ty.clone())203		} else if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {204			remove_attr(&mut arg.attrs, "default");205			(Optionality::Default(default), ty.clone())206		} else if let Some(ty) = extract_type_from_option(ty)? {207			if type_is_path(ty, "Thunk").is_some() {208				return Ok(Self::Lazy {209					is_option: true,210					name: ident.map(|v| v.to_string()),211				});212			}213214			(Optionality::Optional, Box::new(ty.clone()))215		} else {216			(Optionality::Required, ty.clone())217		};218219		let cfg_attrs = arg220			.attrs221			.iter()222			.filter(|a| a.path().is_ident("cfg"))223			.cloned()224			.collect();225226		Ok(Self::Normal {227			ty,228			optionality,229			name: ident.map(|v| v.to_string()),230			cfg_attrs,231		})232	}233}234235#[proc_macro_attribute]236pub fn builtin(237	attr: proc_macro::TokenStream,238	item: proc_macro::TokenStream,239) -> proc_macro::TokenStream {240	let attr = parse_macro_input!(attr as BuiltinAttrs);241	let item_fn = parse_macro_input!(item as ItemFn);242243	match builtin_inner(attr, item_fn) {244		Ok(v) => v.into(),245		Err(e) => e.into_compile_error().into(),246	}247}248249#[allow(clippy::too_many_lines)]250fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {251	let ReturnType::Type(_, result) = &fun.sig.output else {252		return Err(Error::new(253			fun.sig.span(),254			"builtin should return something",255		));256	};257258	let name = fun.sig.ident.to_string();259	let args = fun260		.sig261		.inputs262		.iter_mut()263		.map(|arg| ArgInfo::parse(&name, arg))264		.collect::<Result<Vec<_>>>()?;265266	let params_desc = args.iter().filter_map(|a| match a {267		ArgInfo::Normal {268			optionality,269			name,270			cfg_attrs,271			..272		} => {273			let name = name274				.as_ref()275				.map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});276			let default = match optionality {277				Optionality::Required => quote!(ParamDefault::None),278				Optionality::Optional | Optionality::TypeDefault => quote!(ParamDefault::Exists),279				Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),280			};281			Some(quote! {282				#(#cfg_attrs)*283				[#name => #default],284			})285		}286		ArgInfo::Lazy { is_option, name } => {287			let name = name288				.as_ref()289				.map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});290			Some(quote! {291				[#name => ParamDefault::exists(#is_option)],292			})293		}294		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,295	});296297	let mut id = 0usize;298	let pass = args299		.iter()300		.map(|a| match a {301			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {302				let cid = id;303				id += 1;304				(quote! {#cid}, a)305			}306			ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {307				(quote! {compile_error!("should not use id")}, a)308			}309		})310		.map(|(id, a)| match a {311			ArgInfo::Normal {312				ty,313				optionality,314				name,315				cfg_attrs,316			} => {317				let name = name.as_ref().map_or("<unnamed>", String::as_str);318				let eval = quote! {jrsonnet_evaluator::in_description_frame(319					|| format!("argument <{}> evaluation", #name),320					|| <#ty>::from_untyped(value.evaluate()?),321				)?};322				let value = match optionality {323					Optionality::Required => quote! {{324						let value = parsed[#id].as_ref().expect("args shape is checked");325						#eval326					},},327					Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {328						Some(#eval)329					} else {330						None331					},},332					Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {333						#eval334					} else {335						let v: #ty = #expr;336						v337					},},338					Optionality::TypeDefault => quote! {if let Some(value) = &parsed[#id] {339						#eval340					} else {341						let v: #ty = Default::default();342						v343					},},344				};345				quote! {346					#(#cfg_attrs)*347					#value348				}349			}350			ArgInfo::Lazy { is_option, .. } => {351				if *is_option {352					quote! {if let Some(value) = &parsed[#id] {353						Some(value.clone())354					} else {355						None356					},}357				} else {358					quote! {359						parsed[#id].as_ref().expect("args shape is correct").clone(),360					}361				}362			}363			ArgInfo::Context => quote! {ctx.clone(),},364			ArgInfo::Location => quote! {location,},365			ArgInfo::This => quote! {self,},366		});367368	let fields = attr.fields.iter().map(|field| {369		let attrs = &field.attrs;370		let name = &field.name;371		let ty = &field.ty;372		quote! {373			#(#attrs)*374			pub #name: #ty,375		}376	});377378	let name = &fun.sig.ident;379	let vis = &fun.vis;380	let static_ext = if attr.fields.is_empty() {381		quote! {382			impl #name {383				pub const INST: &'static dyn StaticBuiltin = &#name {};384			}385			impl StaticBuiltin for #name {}386		}387	} else {388		quote! {}389	};390	let static_derive_copy = if attr.fields.is_empty() {391		quote! {, Copy}392	} else {393		quote! {}394	};395396	Ok(quote! {397		#fun398399		#[doc(hidden)]400		#[allow(non_camel_case_types)]401		#[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]402		#vis struct #name {403			#(#fields)*404		}405		const _: () = {406			use ::jrsonnet_evaluator::{407				State, Val,408				function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation},409				Result, Context, typed::Typed,410				parser::Span, params, Thunk,411			};412			params!(413				#(#params_desc)*414			);415416			#static_ext417			impl Builtin for #name418			where419				Self: 'static420			{421				fn name(&self) -> &str {422					stringify!(#name)423				}424				fn params(&self) -> FunctionSignature {425					PARAMS.with(|p| p.clone())426				}427				#[allow(unused_variables)]428				fn call(&self, location: CallLocation<'_>, parsed: &[Option<Thunk<Val>>]) -> Result<Val> {429					let result: #result = #name(#(#pass)*);430					<_ as Typed>::into_result(result)431				}432				fn as_any(&self) -> &dyn ::std::any::Any {433					self434				}435			}436		};437	})438}439440#[derive(Default)]441#[allow(clippy::struct_excessive_bools)]442struct TypedAttr {443	rename: Option<String>,444	aliases: Vec<String>,445	flatten: bool,446	/// flatten(ok) strategy for flattened optionals447	/// field would be None in case of any parsing error (as in serde)448	flatten_ok: bool,449	// Should it be `field+:` instead of `field:`450	add: bool,451	// Should it be `field::` instead of `field:`452	hide: bool,453}454impl Parse for TypedAttr {455	fn parse(input: ParseStream) -> syn::Result<Self> {456		let mut out = Self::default();457		loop {458			let lookahead = input.lookahead1();459			if lookahead.peek(kw::rename) {460				input.parse::<kw::rename>()?;461				input.parse::<Token![=]>()?;462				let name = input.parse::<LitStr>()?;463				if out.rename.is_some() {464					return Err(Error::new(465						name.span(),466						"rename attribute may only be specified once",467					));468				}469				out.rename = Some(name.value());470			} else if lookahead.peek(kw::alias) {471				input.parse::<kw::alias>()?;472				input.parse::<Token![=]>()?;473				let alias = input.parse::<LitStr>()?;474				out.aliases.push(alias.value());475			} else if lookahead.peek(kw::flatten) {476				input.parse::<kw::flatten>()?;477				out.flatten = true;478				if input.peek(token::Paren) {479					let content;480					parenthesized!(content in input);481					let lookahead = content.lookahead1();482					if lookahead.peek(kw::ok) {483						content.parse::<kw::ok>()?;484						out.flatten_ok = true;485					} else {486						return Err(lookahead.error());487					}488				}489			} else if lookahead.peek(kw::add) {490				input.parse::<kw::add>()?;491				out.add = true;492			} else if lookahead.peek(kw::hide) {493				input.parse::<kw::hide>()?;494				out.hide = true;495			} else if input.is_empty() {496				break;497			} else {498				return Err(lookahead.error());499			}500			if input.peek(Token![,]) {501				input.parse::<Token![,]>()?;502			} else {503				break;504			}505		}506		Ok(out)507	}508}509510struct TypedField {511	attr: TypedAttr,512	ident: Ident,513	ty: Type,514	is_option: bool,515	is_lazy: bool,516}517impl TypedField {518	fn parse(field: &syn::Field) -> Result<Self> {519		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();520		let Some(ident) = field.ident.clone() else {521			return Err(Error::new(522				field.span(),523				"this field should appear in output object, but it has no visible name",524			));525		};526		let (is_option, ty) = extract_type_from_option(&field.ty)?527			.map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));528		if is_option && attr.flatten {529			if !attr.flatten_ok {530				return Err(Error::new(531					field.span(),532					"strategy should be set when flattening Option",533				));534			}535		} else if attr.flatten_ok {536			return Err(Error::new(537				field.span(),538				"flatten(ok) is only useable on optional fields",539			));540		}541542		let is_lazy = type_is_path(&ty, "Thunk").is_some();543544		Ok(Self {545			attr,546			ident,547			ty,548			is_option,549			is_lazy,550		})551	}552	/// None if this field is flattened in jsonnet output553	fn name(&self) -> Option<String> {554		if self.attr.flatten {555			return None;556		}557		Some(558			self.attr559				.rename560				.clone()561				.unwrap_or_else(|| self.ident.to_string()),562		)563	}564565	fn expand_field(&self) -> Option<TokenStream> {566		if self.is_option {567			return None;568		}569		let name = self.name()?;570		let ty = &self.ty;571		Some(quote! {572			(#name, <#ty as Typed>::TYPE)573		})574	}575576	fn expand_parse(&self) -> TokenStream {577		if self.is_option {578			self.expand_parse_optional()579		} else {580			self.expand_parse_mandatory()581		}582	}583584	fn expand_parse_optional(&self) -> TokenStream {585		let ident = &self.ident;586		let ty = &self.ty;587588		// optional flatten is handled in same way as serde589		if self.attr.flatten {590			return quote! {591				#ident: <#ty as TypedObj>::parse(&obj).ok(),592			};593		}594595		let name = self.name().unwrap();596		let aliases = &self.attr.aliases;597598		quote! {599			#ident: {600				let __value = if let Some(__v) = obj.get(#name.into())? {601					Some(__v)602				} #(else if let Some(__v) = obj.get(#aliases.into())? {603					Some(__v)604				})* else {605					None606				};607608				__value.map(<#ty as Typed>::from_untyped).transpose()?609			},610		}611	}612613	fn expand_parse_mandatory(&self) -> TokenStream {614		let ident = &self.ident;615		let ty = &self.ty;616617		// optional flatten is handled in same way as serde618		if self.attr.flatten {619			return quote! {620				#ident: <#ty as TypedObj>::parse(&obj)?,621			};622		}623624		let name = self.name().unwrap();625		let aliases = &self.attr.aliases;626627		let error_text = if aliases.is_empty() {628			// clippy does not understand name variable usage in quote! macro629			#[allow(clippy::redundant_clone)]630			name.clone()631		} else {632			format!("{name} (alias {})", aliases.join(", "))633		};634635		quote! {636			#ident: {637				let __value = if let Some(__v) = obj.get(#name.into())? {638					__v639				} #(else if let Some(__v) = obj.get(#aliases.into())? {640					__v641				})* else {642					return Err(ErrorKind::NoSuchField(#error_text.into(), vec![]).into());643				};644645				<#ty as Typed>::from_untyped(__value)?646			},647		}648	}649650	fn expand_serialize(&self) -> TokenStream {651		let ident = &self.ident;652		let ty = &self.ty;653		self.name().map_or_else(654			|| {655				if self.is_option {656					quote! {657						if let Some(value) = self.#ident {658							<#ty as TypedObj>::serialize(value, out)?;659						}660					}661				} else {662					quote! {663						<#ty as TypedObj>::serialize(self.#ident, out)?;664					}665				}666			},667			|name| {668				let hide = if self.attr.hide {669					quote! {.hide()}670				} else {671					quote! {}672				};673				let add = if self.attr.add {674					quote! {.add()}675				} else {676					quote! {}677				};678				let value = if self.is_lazy {679					quote! {680						out.field(#name)681							#hide682							#add683							.try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;684					}685				} else {686					quote! {687						out.field(#name)688							#hide689							#add690							.try_value(<#ty as Typed>::into_untyped(value)?)?;691					}692				};693				if self.is_option {694					quote! {695						if let Some(value) = self.#ident {696							#value697						}698					}699				} else {700					quote! {701						{702							let value = self.#ident;703							#value704						}705					}706				}707			},708		)709	}710}711712#[proc_macro_derive(Typed, attributes(typed))]713pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {714	let input = parse_macro_input!(item as DeriveInput);715716	match derive_typed_inner(input) {717		Ok(v) => v.into(),718		Err(e) => e.to_compile_error().into(),719	}720}721722fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {723	let syn::Data::Struct(data) = &input.data else {724		return Err(Error::new(input.span(), "only structs supported"));725	};726727	let ident = &input.ident;728	let fields = data729		.fields730		.iter()731		.map(TypedField::parse)732		.collect::<Result<Vec<_>>>()?;733734	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();735736	let typed = {737		let fields = fields738			.iter()739			.filter_map(TypedField::expand_field)740			.collect::<Vec<_>>();741		quote! {742			impl #impl_generics Typed for #ident #ty_generics #where_clause {743				const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[744					#(#fields,)*745				]);746747				fn from_untyped(value: Val) -> JrResult<Self> {748					let obj = value.as_obj().expect("shape is correct");749					Self::parse(&obj)750				}751752				fn into_untyped(value: Self) -> JrResult<Val> {753					let mut out = ObjValueBuilder::new();754					value.serialize(&mut out)?;755					Ok(Val::Obj(out.build()))756				}757758			}759		}760	};761762	let fields_parse = fields.iter().map(TypedField::expand_parse);763	let fields_serialize = fields764		.iter()765		.map(TypedField::expand_serialize)766		.collect::<Vec<_>>();767768	Ok(quote! {769		const _: () = {770			use ::jrsonnet_evaluator::{771				typed::{ComplexValType, Typed, TypedObj, CheckType},772				Val, State,773				error::{ErrorKind, Result as JrResult},774				ObjValueBuilder, ObjValue,775			};776777			#typed778779			impl #impl_generics TypedObj for #ident #ty_generics #where_clause {780				fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {781					#(#fields_serialize)*782783					Ok(())784				}785				fn parse(obj: &ObjValue) -> JrResult<Self> {786					Ok(Self {787						#(#fields_parse)*788					})789				}790			}791		};792	})793}794795struct FormatInput {796	formatting: LitStr,797	arguments: Vec<Expr>,798}799impl Parse for FormatInput {800	fn parse(input: ParseStream) -> Result<Self> {801		let formatting = input.parse()?;802		let mut arguments = Vec::new();803804		while input.peek(Token![,]) {805			input.parse::<Token![,]>()?;806			if input.is_empty() {807				// Trailing comma808				break;809			}810			let expr = input.parse()?;811			arguments.push(expr);812		}813814		if !input.is_empty() {815			return Err(syn::Error::new(input.span(), "unexpected trailing input"));816		}817818		Ok(Self {819			formatting,820			arguments,821		})822	}823}824fn is_format_str(i: &str) -> bool {825	let mut is_plain = true;826	// -1 = {827	// +1 = }828	let mut is_bracket = 0i8;829	for ele in i.chars() {830		match ele {831			'{' if is_bracket == -1 => {832				is_bracket = 0;833			}834			'}' if is_bracket == -1 => {835				is_plain = false;836				break;837			}838			'}' if is_bracket == 1 => {839				is_bracket = 0;840			}841			'{' if is_bracket == 1 => {842				is_plain = false;843				break;844			}845			'{' => {846				is_bracket = -1;847			}848			'}' => {849				is_bracket = 1;850			}851			_ if is_bracket != 0 => {852				is_plain = false;853				break;854			}855			_ => {}856		}857	}858	!is_plain || is_bracket != 0859}860impl FormatInput {861	fn expand(self) -> TokenStream {862		let format = self.formatting;863		if is_format_str(&format.value()) {864			let args = self.arguments;865			quote! {866				::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))867			}868		} else {869			if let Some(first) = self.arguments.first() {870				return syn::Error::new(871					first.span(),872					"string has no formatting codes, it should not have the arguments",873				)874				.into_compile_error();875			}876			quote! {877				::jrsonnet_evaluator::IStr::from(#format)878			}879		}880	}881}882883/// `IStr` formatting helper884///885/// Using `format!("literal with no codes").into()` is slower than just `"literal with no codes".into()`886/// This macro looks for formatting codes in the input string, and uses887/// `format!()` only when necessary888#[proc_macro]889pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {890	let input = parse_macro_input!(input as FormatInput);891	input.expand().into()892}893894/// Create Thunk using closure syntax895#[proc_macro]896#[allow(non_snake_case)]897pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {898	let input = parse_macro_input!(input as ExprClosure);899900	let span = input.inputs.span();901	let move_check = input.capture.is_none().then(|| {902		quote_spanned! {span => {903			compile_error!("Thunk! needs to be called with move closure");904		}}905	});906907	let (env, closure, args) = syn_dissect_closure::split_env(input);908909	let trace_check = args.iter().map(|el| {910		let span = el.span();911		quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}912	});913914	quote! {{915		#move_check916		#(#trace_check)*917		::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))918	}}.into()919}