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

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, Pat, Path, PathArguments, Result, ReturnType, Token, Type,14};1516fn parse_attr<A: Parse, I>(attrs: &[Attribute], ident: I) -> Result<Option<A>>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(None);31	}32	let attr = attrs[0];33	let attr = attr.parse_args::<A>()?;3435	Ok(Some(attr))36}37fn remove_attr<I>(attrs: &mut Vec<Attribute>, ident: I)38where39	Ident: PartialEq<I>,40{41	attrs.retain(|a| !a.path().is_ident(&ident));42}4344fn path_is(path: &Path, needed: &str) -> bool {45	path.leading_colon.is_none()46		&& !path.segments.is_empty()47		&& path.segments.iter().last().unwrap().ident == needed48}4950fn type_is_path<'ty>(ty: &'ty Type, needed: &str) -> Option<&'ty PathArguments> {51	match ty {52		Type::Path(path) if path.qself.is_none() && path_is(&path.path, needed) => {53			let args = &path.path.segments.iter().last().unwrap().arguments;54			Some(args)55		}56		_ => None,57	}58}5960fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {61	let Some(args) = type_is_path(ty, "Option") else {62		return Ok(None);63	};64	// It should have only on angle-bracketed param ("<String>"):65	let PathArguments::AngleBracketed(params) = args else {66		return Err(Error::new(args.span(), "missing option generic"));67	};68	let generic_arg = params.args.iter().next().unwrap();69	// This argument must be a type:70	let GenericArgument::Type(ty) = generic_arg else {71		return Err(Error::new(72			generic_arg.span(),73			"option generic should be a type",74		));75	};76	Ok(Some(ty))77}7879struct Field {80	attrs: Vec<Attribute>,81	name: Ident,82	_colon: Token![:],83	ty: Type,84}85impl Parse for Field {86	fn parse(input: ParseStream) -> syn::Result<Self> {87		Ok(Self {88			attrs: input.call(Attribute::parse_outer)?,89			name: input.parse()?,90			_colon: input.parse()?,91			ty: input.parse()?,92		})93	}94}9596mod kw {97	syn::custom_keyword!(fields);98	syn::custom_keyword!(rename);99	syn::custom_keyword!(alias);100	syn::custom_keyword!(flatten);101	syn::custom_keyword!(add);102	syn::custom_keyword!(hide);103	syn::custom_keyword!(ok);104}105106struct BuiltinAttrs {107	fields: Vec<Field>,108}109impl Parse for BuiltinAttrs {110	fn parse(input: ParseStream) -> syn::Result<Self> {111		if input.is_empty() {112			return Ok(Self { fields: Vec::new() });113		}114		input.parse::<kw::fields>()?;115		let fields;116		parenthesized!(fields in input);117		let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;118		Ok(Self {119			fields: p.into_iter().collect(),120		})121	}122}123124enum Optionality {125	Required,126	Optional,127	Default(Expr),128}129130enum ArgInfo {131	Normal {132		ty: Box<Type>,133		optionality: Optionality,134		name: Option<String>,135		cfg_attrs: Vec<Attribute>,136	},137	Lazy {138		is_option: bool,139		name: Option<String>,140	},141	Context,142	Location,143	This,144}145146impl ArgInfo {147	fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {148		let FnArg::Typed(arg) = arg else {149			unreachable!()150		};151		let ident = match &arg.pat as &Pat {152			Pat::Ident(i) => Some(i.ident.clone()),153			_ => None,154		};155		let ty = &arg.ty;156		if type_is_path(ty, "Context").is_some() {157			return Ok(Self::Context);158		} else if type_is_path(ty, "CallLocation").is_some() {159			return Ok(Self::Location);160		} else if type_is_path(ty, "Thunk").is_some() {161			return Ok(Self::Lazy {162				is_option: false,163				name: ident.map(|v| v.to_string()),164			});165		}166167		match ty as &Type {168			Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),169			_ => {}170		}171172		let (optionality, ty) = if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {173			remove_attr(&mut arg.attrs, "default");174			(Optionality::Default(default), ty.clone())175		} else if let Some(ty) = extract_type_from_option(ty)? {176			if type_is_path(ty, "Thunk").is_some() {177				return Ok(Self::Lazy {178					is_option: true,179					name: ident.map(|v| v.to_string()),180				});181			}182183			(Optionality::Optional, Box::new(ty.clone()))184		} else {185			(Optionality::Required, ty.clone())186		};187188		let cfg_attrs = arg189			.attrs190			.iter()191			.filter(|a| a.path().is_ident("cfg"))192			.cloned()193			.collect();194195		Ok(Self::Normal {196			ty,197			optionality,198			name: ident.map(|v| v.to_string()),199			cfg_attrs,200		})201	}202}203204#[proc_macro_attribute]205pub fn builtin(206	attr: proc_macro::TokenStream,207	item: proc_macro::TokenStream,208) -> proc_macro::TokenStream {209	let attr = parse_macro_input!(attr as BuiltinAttrs);210	let item_fn = parse_macro_input!(item as ItemFn);211212	match builtin_inner(attr, item_fn) {213		Ok(v) => v.into(),214		Err(e) => e.into_compile_error().into(),215	}216}217218#[allow(clippy::too_many_lines)]219fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {220	let ReturnType::Type(_, result) = &fun.sig.output else {221		return Err(Error::new(222			fun.sig.span(),223			"builtin should return something",224		));225	};226227	let name = fun.sig.ident.to_string();228	let args = fun229		.sig230		.inputs231		.iter_mut()232		.map(|arg| ArgInfo::parse(&name, arg))233		.collect::<Result<Vec<_>>>()?;234235	let params_desc = args.iter().filter_map(|a| match a {236		ArgInfo::Normal {237			optionality,238			name,239			cfg_attrs,240			..241		} => {242			let name = name.as_ref().map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});243			let default = match optionality {244				Optionality::Required => quote!(ParamDefault::None),245				Optionality::Optional => quote!(ParamDefault::Exists),246				Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),247			};248			Some(quote! {249				#(#cfg_attrs)*250				[#name => #default],251			})252		}253		ArgInfo::Lazy { is_option, name } => {254			let name = name.as_ref().map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});255			Some(quote! {256				[#name => ParamDefault::exists(#is_option)],257			})258		}259		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,260	});261262	let mut id = 0usize;263	let pass = args264		.iter()265		.map(|a| match a {266			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {267				let cid = id;268				id += 1;269				(quote! {#cid}, a)270			}271			ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {272				(quote! {compile_error!("should not use id")}, a)273			}274		})275		.map(|(id, a)| match a {276			ArgInfo::Normal {277				ty,278				optionality,279				name,280				cfg_attrs,281			} => {282				let name = name.as_ref().map_or("<unnamed>", String::as_str);283				let eval = quote! {jrsonnet_evaluator::in_description_frame(284					|| format!("argument <{}> evaluation", #name),285					|| <#ty>::from_untyped(value.evaluate()?),286				)?};287				let value = match optionality {288					Optionality::Required => quote! {{289						let value = parsed[#id].as_ref().expect("args shape is checked");290						#eval291					},},292					Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {293						Some(#eval)294					} else {295						None296					},},297					Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {298						#eval299					} else {300						let v: #ty = #expr;301						v302					},},303				};304				quote! {305					#(#cfg_attrs)*306					#value307				}308			}309			ArgInfo::Lazy { is_option, .. } => {310				if *is_option {311					quote! {if let Some(value) = &parsed[#id] {312						Some(value.clone())313					} else {314						None315					},}316				} else {317					quote! {318						parsed[#id].as_ref().expect("args shape is correct").clone(),319					}320				}321			}322			ArgInfo::Context => quote! {ctx.clone(),},323			ArgInfo::Location => quote! {location,},324			ArgInfo::This => quote! {self,},325		});326327	let fields = attr.fields.iter().map(|field| {328		let attrs = &field.attrs;329		let name = &field.name;330		let ty = &field.ty;331		quote! {332			#(#attrs)*333			pub #name: #ty,334		}335	});336337	let name = &fun.sig.ident;338	let vis = &fun.vis;339	let static_ext = if attr.fields.is_empty() {340		quote! {341			impl #name {342				pub const INST: &'static dyn StaticBuiltin = &#name {};343			}344			impl StaticBuiltin for #name {}345		}346	} else {347		quote! {}348	};349	let static_derive_copy = if attr.fields.is_empty() {350		quote! {, Copy}351	} else {352		quote! {}353	};354355	Ok(quote! {356		#fun357358		#[doc(hidden)]359		#[allow(non_camel_case_types)]360		#[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]361		#vis struct #name {362			#(#fields)*363		}364		const _: () = {365			use ::jrsonnet_evaluator::{366				State, Val,367				function::{builtin::{Builtin, StaticBuiltin, ParamParse, ParamName, ParamDefault}, CallLocation, ArgsLike, parse::parse_builtin_call},368				Result, Context, typed::Typed,369				parser::Span, params,370			};371			params!(372				#(#params_desc)*373			);374375			#static_ext376			impl Builtin for #name377			where378				Self: 'static379			{380				fn name(&self) -> &str {381					stringify!(#name)382				}383				fn params(&self) -> &[ParamParse] {384					/// Safety: ParamParse contains IStr, which is thread-local, thus neither Send or Sync385					/// The result of this transmute can not outlive the thread, thus 'static here is equivalent to the386					/// nightly-only 'thread387					PARAMS.with(|p| unsafe { std::mem::transmute::<&[ParamParse], &'static [ParamParse]>(p.as_slice()) })388				}389				#[allow(unused_variables)]390				fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {391					let parsed = parse_builtin_call(ctx.clone(), self.params(), args, false)?;392393					let result: #result = #name(#(#pass)*);394					<_ as Typed>::into_result(result)395				}396				fn as_any(&self) -> &dyn ::std::any::Any {397					self398				}399			}400		};401	})402}403404#[derive(Default)]405#[allow(clippy::struct_excessive_bools)]406struct TypedAttr {407	rename: Option<String>,408	aliases: Vec<String>,409	flatten: bool,410	/// flatten(ok) strategy for flattened optionals411	/// field would be None in case of any parsing error (as in serde)412	flatten_ok: bool,413	// Should it be `field+:` instead of `field:`414	add: bool,415	// Should it be `field::` instead of `field:`416	hide: bool,417}418impl Parse for TypedAttr {419	fn parse(input: ParseStream) -> syn::Result<Self> {420		let mut out = Self::default();421		loop {422			let lookahead = input.lookahead1();423			if lookahead.peek(kw::rename) {424				input.parse::<kw::rename>()?;425				input.parse::<Token![=]>()?;426				let name = input.parse::<LitStr>()?;427				if out.rename.is_some() {428					return Err(Error::new(429						name.span(),430						"rename attribute may only be specified once",431					));432				}433				out.rename = Some(name.value());434			} else if lookahead.peek(kw::alias) {435				input.parse::<kw::alias>()?;436				input.parse::<Token![=]>()?;437				let alias = input.parse::<LitStr>()?;438				out.aliases.push(alias.value());439			} else if lookahead.peek(kw::flatten) {440				input.parse::<kw::flatten>()?;441				out.flatten = true;442				if input.peek(token::Paren) {443					let content;444					parenthesized!(content in input);445					let lookahead = content.lookahead1();446					if lookahead.peek(kw::ok) {447						content.parse::<kw::ok>()?;448						out.flatten_ok = true;449					} else {450						return Err(lookahead.error());451					}452				}453			} else if lookahead.peek(kw::add) {454				input.parse::<kw::add>()?;455				out.add = true;456			} else if lookahead.peek(kw::hide) {457				input.parse::<kw::hide>()?;458				out.hide = true;459			} else if input.is_empty() {460				break;461			} else {462				return Err(lookahead.error());463			}464			if input.peek(Token![,]) {465				input.parse::<Token![,]>()?;466			} else {467				break;468			}469		}470		Ok(out)471	}472}473474struct TypedField {475	attr: TypedAttr,476	ident: Ident,477	ty: Type,478	is_option: bool,479	is_lazy: bool,480}481impl TypedField {482	fn parse(field: &syn::Field) -> Result<Self> {483		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();484		let Some(ident) = field.ident.clone() else {485			return Err(Error::new(486				field.span(),487				"this field should appear in output object, but it has no visible name",488			));489		};490		let (is_option, ty) = extract_type_from_option(&field.ty)?491			.map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));492		if is_option && attr.flatten {493			if !attr.flatten_ok {494				return Err(Error::new(495					field.span(),496					"strategy should be set when flattening Option",497				));498			}499		} else if attr.flatten_ok {500			return Err(Error::new(501				field.span(),502				"flatten(ok) is only useable on optional fields",503			));504		}505506		let is_lazy = type_is_path(&ty, "Thunk").is_some();507508		Ok(Self {509			attr,510			ident,511			ty,512			is_option,513			is_lazy,514		})515	}516	/// None if this field is flattened in jsonnet output517	fn name(&self) -> Option<String> {518		if self.attr.flatten {519			return None;520		}521		Some(522			self.attr523				.rename524				.clone()525				.unwrap_or_else(|| self.ident.to_string()),526		)527	}528529	fn expand_field(&self) -> Option<TokenStream> {530		if self.is_option {531			return None;532		}533		let name = self.name()?;534		let ty = &self.ty;535		Some(quote! {536			(#name, <#ty as Typed>::TYPE)537		})538	}539540	fn expand_parse(&self) -> TokenStream {541		if self.is_option {542			self.expand_parse_optional()543		} else {544			self.expand_parse_mandatory()545		}546	}547548	fn expand_parse_optional(&self) -> TokenStream {549		let ident = &self.ident;550		let ty = &self.ty;551552		// optional flatten is handled in same way as serde553		if self.attr.flatten {554			return quote! {555				#ident: <#ty as TypedObj>::parse(&obj).ok(),556			};557		}558559		let name = self.name().unwrap();560		let aliases = &self.attr.aliases;561562		quote! {563			#ident: {564				let __value = if let Some(__v) = obj.get(#name.into())? {565					Some(__v)566				} #(else if let Some(__v) = obj.get(#aliases.into())? {567					Some(__v)568				})* else {569					None570				};571572				__value.map(<#ty as Typed>::from_untyped).transpose()?573			},574		}575	}576577	fn expand_parse_mandatory(&self) -> TokenStream {578		let ident = &self.ident;579		let ty = &self.ty;580581		// optional flatten is handled in same way as serde582		if self.attr.flatten {583			return quote! {584				#ident: <#ty as TypedObj>::parse(&obj)?,585			};586		}587588		let name = self.name().unwrap();589		let aliases = &self.attr.aliases;590591		let error_text = if aliases.is_empty() {592			// clippy does not understand name variable usage in quote! macro593			#[allow(clippy::redundant_clone)]594			name.clone()595		} else {596			format!("{name} (alias {})", aliases.join(", "))597		};598599		quote! {600			#ident: {601				let __value = if let Some(__v) = obj.get(#name.into())? {602					__v603				} #(else if let Some(__v) = obj.get(#aliases.into())? {604					__v605				})* else {606					return Err(ErrorKind::NoSuchField(#error_text.into(), vec![]).into());607				};608609				<#ty as Typed>::from_untyped(__value)?610			},611		}612	}613614	fn expand_serialize(&self) -> TokenStream {615		let ident = &self.ident;616		let ty = &self.ty;617		self.name().map_or_else(618			|| {619				if self.is_option {620					quote! {621						if let Some(value) = self.#ident {622							<#ty as TypedObj>::serialize(value, out)?;623						}624					}625				} else {626					quote! {627						<#ty as TypedObj>::serialize(self.#ident, out)?;628					}629				}630			},631			|name| {632				let hide = if self.attr.hide {633					quote! {.hide()}634				} else {635					quote! {}636				};637				let add = if self.attr.add {638					quote! {.add()}639				} else {640					quote! {}641				};642				let value = if self.is_lazy {643					quote! {644						out.field(#name)645							#hide646							#add647							.try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;648					}649				} else {650					quote! {651						out.field(#name)652							#hide653							#add654							.try_value(<#ty as Typed>::into_untyped(value)?)?;655					}656				};657				if self.is_option {658					quote! {659						if let Some(value) = self.#ident {660							#value661						}662					}663				} else {664					quote! {665						{666							let value = self.#ident;667							#value668						}669					}670				}671			},672		)673	}674}675676#[proc_macro_derive(Typed, attributes(typed))]677pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {678	let input = parse_macro_input!(item as DeriveInput);679680	match derive_typed_inner(input) {681		Ok(v) => v.into(),682		Err(e) => e.to_compile_error().into(),683	}684}685686fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {687	let syn::Data::Struct(data) = &input.data else {688		return Err(Error::new(input.span(), "only structs supported"));689	};690691	let ident = &input.ident;692	let fields = data693		.fields694		.iter()695		.map(TypedField::parse)696		.collect::<Result<Vec<_>>>()?;697698	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();699700	let typed = {701		let fields = fields702			.iter()703			.filter_map(TypedField::expand_field)704			.collect::<Vec<_>>();705		quote! {706			impl #impl_generics Typed for #ident #ty_generics #where_clause {707				const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[708					#(#fields,)*709				]);710711				fn from_untyped(value: Val) -> JrResult<Self> {712					let obj = value.as_obj().expect("shape is correct");713					Self::parse(&obj)714				}715716				fn into_untyped(value: Self) -> JrResult<Val> {717					let mut out = ObjValueBuilder::new();718					value.serialize(&mut out)?;719					Ok(Val::Obj(out.build()))720				}721722			}723		}724	};725726	let fields_parse = fields.iter().map(TypedField::expand_parse);727	let fields_serialize = fields728		.iter()729		.map(TypedField::expand_serialize)730		.collect::<Vec<_>>();731732	Ok(quote! {733		const _: () = {734			use ::jrsonnet_evaluator::{735				typed::{ComplexValType, Typed, TypedObj, CheckType},736				Val, State,737				error::{ErrorKind, Result as JrResult},738				ObjValueBuilder, ObjValue,739			};740741			#typed742743			impl #impl_generics TypedObj for #ident #ty_generics #where_clause {744				fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {745					#(#fields_serialize)*746747					Ok(())748				}749				fn parse(obj: &ObjValue) -> JrResult<Self> {750					Ok(Self {751						#(#fields_parse)*752					})753				}754			}755		};756	})757}758759struct FormatInput {760	formatting: LitStr,761	arguments: Vec<Expr>,762}763impl Parse for FormatInput {764	fn parse(input: ParseStream) -> Result<Self> {765		let formatting = input.parse()?;766		let mut arguments = Vec::new();767768		while input.peek(Token![,]) {769			input.parse::<Token![,]>()?;770			if input.is_empty() {771				// Trailing comma772				break;773			}774			let expr = input.parse()?;775			arguments.push(expr);776		}777778		if !input.is_empty() {779			return Err(syn::Error::new(input.span(), "unexpected trailing input"));780		}781782		Ok(Self {783			formatting,784			arguments,785		})786	}787}788fn is_format_str(i: &str) -> bool {789	let mut is_plain = true;790	// -1 = {791	// +1 = }792	let mut is_bracket = 0i8;793	for ele in i.chars() {794		match ele {795			'{' if is_bracket == -1 => {796				is_bracket = 0;797			}798			'}' if is_bracket == -1 => {799				is_plain = false;800				break;801			}802			'}' if is_bracket == 1 => {803				is_bracket = 0;804			}805			'{' if is_bracket == 1 => {806				is_plain = false;807				break;808			}809			'{' => {810				is_bracket = -1;811			}812			'}' => {813				is_bracket = 1;814			}815			_ if is_bracket != 0 => {816				is_plain = false;817				break;818			}819			_ => {}820		}821	}822	!is_plain || is_bracket != 0823}824impl FormatInput {825	fn expand(self) -> TokenStream {826		let format = self.formatting;827		if is_format_str(&format.value()) {828			let args = self.arguments;829			quote! {830				::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))831			}832		} else {833			if let Some(first) = self.arguments.first() {834				return syn::Error::new(835					first.span(),836					"string has no formatting codes, it should not have the arguments",837				)838				.into_compile_error();839			}840			quote! {841				::jrsonnet_evaluator::IStr::from(#format)842			}843		}844	}845}846847/// `IStr` formatting helper848///849/// Using `format!("literal with no codes").into()` is slower than just `"literal with no codes".into()`850/// This macro looks for formatting codes in the input string, and uses851/// `format!()` only when necessary852#[proc_macro]853pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {854	let input = parse_macro_input!(input as FormatInput);855	input.expand().into()856}857858/// Create Thunk using closure syntax859#[proc_macro]860#[allow(non_snake_case)]861pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {862	let input = parse_macro_input!(input as ExprClosure);863864	let span = input.inputs.span();865	let move_check = input.capture.is_none().then(|| {866		quote_spanned! {span => {867			compile_error!("Thunk! needs to be called with move closure");868		}}869	});870871	let (env, closure, args) = syn_dissect_closure::split_env(input);872873	let trace_check = args.iter().map(|el| {874		let span = el.span();875		quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}876	});877878	quote! {{879		#move_check880		#(#trace_check)*881		::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))882	}}.into()883}