git.delta.rocks / jrsonnet / refs/commits / 7b38a7f3268f

1use std::string::String;23use proc_macro2::TokenStream;4use quote::quote;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, FnArg, GenericArgument, Ident, ItemFn, LitStr, Pat, Path,13	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!(flatten);100	syn::custom_keyword!(add);101	syn::custom_keyword!(hide);102	syn::custom_keyword!(ok);103}104105struct EmptyAttr;106impl Parse for EmptyAttr {107	fn parse(_input: ParseStream) -> Result<Self> {108		Ok(Self)109	}110}111112struct BuiltinAttrs {113	fields: Vec<Field>,114}115impl Parse for BuiltinAttrs {116	fn parse(input: ParseStream) -> syn::Result<Self> {117		if input.is_empty() {118			return Ok(Self { fields: Vec::new() });119		}120		input.parse::<kw::fields>()?;121		let fields;122		parenthesized!(fields in input);123		let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;124		Ok(Self {125			fields: p.into_iter().collect(),126		})127	}128}129130enum Optionality {131	Required,132	Optional,133	Default(Expr),134}135136enum ArgInfo {137	Normal {138		ty: Box<Type>,139		optionality: Optionality,140		name: Option<String>,141		cfg_attrs: Vec<Attribute>,142	},143	Lazy {144		is_option: bool,145		name: Option<String>,146	},147	Context,148	Location,149	This,150}151152impl ArgInfo {153	fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {154		let FnArg::Typed(arg) = arg else {155			unreachable!()156		};157		let ident = match &arg.pat as &Pat {158			Pat::Ident(i) => Some(i.ident.clone()),159			_ => None,160		};161		let ty = &arg.ty;162		if type_is_path(ty, "Context").is_some() {163			return Ok(Self::Context);164		} else if type_is_path(ty, "CallLocation").is_some() {165			return Ok(Self::Location);166		} else if type_is_path(ty, "Thunk").is_some() {167			return Ok(Self::Lazy {168				is_option: false,169				name: ident.map(|v| v.to_string()),170			});171		}172173		match ty as &Type {174			Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),175			_ => {}176		}177178		let (optionality, ty) = if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {179			remove_attr(&mut arg.attrs, "default");180			(Optionality::Default(default), ty.clone())181		} else if let Some(ty) = extract_type_from_option(ty)? {182			if type_is_path(ty, "Thunk").is_some() {183				return Ok(Self::Lazy {184					is_option: true,185					name: ident.map(|v| v.to_string()),186				});187			}188189			(Optionality::Optional, Box::new(ty.clone()))190		} else {191			(Optionality::Required, ty.clone())192		};193194		let cfg_attrs = arg195			.attrs196			.iter()197			.filter(|a| a.path().is_ident("cfg"))198			.cloned()199			.collect();200201		Ok(Self::Normal {202			ty,203			optionality,204			name: ident.map(|v| v.to_string()),205			cfg_attrs,206		})207	}208}209210#[proc_macro_attribute]211pub fn builtin(212	attr: proc_macro::TokenStream,213	item: proc_macro::TokenStream,214) -> proc_macro::TokenStream {215	let attr = parse_macro_input!(attr as BuiltinAttrs);216	let item_fn = parse_macro_input!(item as ItemFn);217218	match builtin_inner(attr, item_fn) {219		Ok(v) => v.into(),220		Err(e) => e.into_compile_error().into(),221	}222}223224#[allow(clippy::too_many_lines)]225fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {226	let ReturnType::Type(_, result) = &fun.sig.output else {227		return Err(Error::new(228			fun.sig.span(),229			"builtin should return something",230		));231	};232233	let name = fun.sig.ident.to_string();234	let args = fun235		.sig236		.inputs237		.iter_mut()238		.map(|arg| ArgInfo::parse(&name, arg))239		.collect::<Result<Vec<_>>>()?;240241	let params_desc = args.iter().filter_map(|a| match a {242		ArgInfo::Normal {243			optionality,244			name,245			cfg_attrs,246			..247		} => {248			let name = name249				.as_ref()250				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});251			let default = match optionality {252				Optionality::Required => quote!(ParamDefault::None),253				Optionality::Optional => quote!(ParamDefault::Exists),254				Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),255			};256			Some(quote! {257				#(#cfg_attrs)*258				BuiltinParam::new(#name, #default),259			})260		}261		ArgInfo::Lazy { is_option, name } => {262			let name = name263				.as_ref()264				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});265			Some(quote! {266				BuiltinParam::new(#name, ParamDefault::exists(#is_option)),267			})268		}269		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,270	});271272	let mut id = 0usize;273	let pass = args274		.iter()275		.map(|a| match a {276			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {277				let cid = id;278				id += 1;279				(quote! {#cid}, a)280			}281			ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {282				(quote! {compile_error!("should not use id")}, a)283			}284		})285		.map(|(id, a)| match a {286			ArgInfo::Normal {287				ty,288				optionality,289				name,290				cfg_attrs,291			} => {292				let name = name.as_ref().map_or("<unnamed>", String::as_str);293				let eval = quote! {jrsonnet_evaluator::in_description_frame(294					|| format!("argument <{}> evaluation", #name),295					|| <#ty>::from_untyped(value.evaluate()?),296				)?};297				let value = match optionality {298					Optionality::Required => quote! {{299						let value = parsed[#id].as_ref().expect("args shape is checked");300						#eval301					},},302					Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {303						Some(#eval)304					} else {305						None306					},},307					Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {308						#eval309					} else {310						let v: #ty = #expr;311						v312					},},313				};314				quote! {315					#(#cfg_attrs)*316					#value317				}318			}319			ArgInfo::Lazy { is_option, .. } => {320				if *is_option {321					quote! {if let Some(value) = &parsed[#id] {322						Some(value.clone())323					} else {324						None325					},}326				} else {327					quote! {328						parsed[#id].as_ref().expect("args shape is correct").clone(),329					}330				}331			}332			ArgInfo::Context => quote! {ctx.clone(),},333			ArgInfo::Location => quote! {location,},334			ArgInfo::This => quote! {self,},335		});336337	let fields = attr.fields.iter().map(|field| {338		let attrs = &field.attrs;339		let name = &field.name;340		let ty = &field.ty;341		quote! {342			#(#attrs)*343			pub #name: #ty,344		}345	});346347	let name = &fun.sig.ident;348	let vis = &fun.vis;349	let static_ext = if attr.fields.is_empty() {350		quote! {351			impl #name {352				pub const INST: &'static dyn StaticBuiltin = &#name {};353			}354			impl StaticBuiltin for #name {}355		}356	} else {357		quote! {}358	};359	let static_derive_copy = if attr.fields.is_empty() {360		quote! {, Copy}361	} else {362		quote! {}363	};364365	Ok(quote! {366		#fun367368		#[doc(hidden)]369		#[allow(non_camel_case_types)]370		#[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]371		#vis struct #name {372			#(#fields)*373		}374		const _: () = {375			use ::jrsonnet_evaluator::{376				State, Val,377				function::{builtin::{Builtin, StaticBuiltin, BuiltinParam, ParamName, ParamDefault}, CallLocation, ArgsLike, parse::parse_builtin_call},378				Result, Context, typed::Typed,379				parser::Span,380			};381			const PARAMS: &'static [BuiltinParam] = &[382				#(#params_desc)*383			];384385			#static_ext386			impl Builtin for #name387			where388				Self: 'static389			{390				fn name(&self) -> &str {391					stringify!(#name)392				}393				fn params(&self) -> &[BuiltinParam] {394					PARAMS395				}396				#[allow(unused_variables)]397				fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {398					let parsed = parse_builtin_call(ctx.clone(), &PARAMS, args, false)?;399400					let result: #result = #name(#(#pass)*);401					<_ as Typed>::into_result(result)402				}403				fn as_any(&self) -> &dyn ::std::any::Any {404					self405				}406			}407		};408	})409}410411#[derive(Default)]412#[allow(clippy::struct_excessive_bools)]413struct TypedAttr {414	rename: Option<String>,415	flatten: bool,416	/// flatten(ok) strategy for flattened optionals417	/// field would be None in case of any parsing error (as in serde)418	flatten_ok: bool,419	// Should it be `field+:` instead of `field:`420	add: bool,421	// Should it be `field::` instead of `field:`422	hide: bool,423}424impl Parse for TypedAttr {425	fn parse(input: ParseStream) -> syn::Result<Self> {426		let mut out = Self::default();427		loop {428			let lookahead = input.lookahead1();429			if lookahead.peek(kw::rename) {430				input.parse::<kw::rename>()?;431				input.parse::<Token![=]>()?;432				let name = input.parse::<LitStr>()?;433				if out.rename.is_some() {434					return Err(Error::new(435						name.span(),436						"rename attribute may only be specified once",437					));438				}439				out.rename = Some(name.value());440			} else if lookahead.peek(kw::flatten) {441				input.parse::<kw::flatten>()?;442				out.flatten = true;443				if input.peek(token::Paren) {444					let content;445					parenthesized!(content in input);446					let lookahead = content.lookahead1();447					if lookahead.peek(kw::ok) {448						content.parse::<kw::ok>()?;449						out.flatten_ok = true;450					} else {451						return Err(lookahead.error());452					}453				}454			} else if lookahead.peek(kw::add) {455				input.parse::<kw::add>()?;456				out.add = true;457			} else if lookahead.peek(kw::hide) {458				input.parse::<kw::hide>()?;459				out.hide = true;460			} else if input.is_empty() {461				break;462			} else {463				return Err(lookahead.error());464			}465			if input.peek(Token![,]) {466				input.parse::<Token![,]>()?;467			} else {468				break;469			}470		}471		Ok(out)472	}473}474475struct TypedField {476	attr: TypedAttr,477	ident: Ident,478	ty: Type,479	is_option: 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		Ok(Self {507			attr,508			ident,509			ty,510			is_option,511		})512	}513	/// None if this field is flattened in jsonnet output514	fn name(&self) -> Option<String> {515		if self.attr.flatten {516			return None;517		}518		Some(519			self.attr520				.rename521				.clone()522				.unwrap_or_else(|| self.ident.to_string()),523		)524	}525526	fn expand_field(&self) -> Option<TokenStream> {527		if self.is_option {528			return None;529		}530		let name = self.name()?;531		let ty = &self.ty;532		Some(quote! {533			(#name, <#ty as Typed>::TYPE)534		})535	}536	fn expand_parse(&self) -> TokenStream {537		let ident = &self.ident;538		let ty = &self.ty;539		if self.attr.flatten {540			// optional flatten is handled in same way as serde541			return if self.is_option {542				quote! {543					#ident: <#ty as TypedObj>::parse(&obj).ok(),544				}545			} else {546				quote! {547					#ident: <#ty as TypedObj>::parse(&obj)?,548				}549			};550		};551552		let name = self.name().unwrap();553		let value = if self.is_option {554			quote! {555				if let Some(value) = obj.get(#name.into())? {556					Some(<#ty as Typed>::from_untyped(value)?)557				} else {558					None559				}560			}561		} else {562			quote! {563				<#ty as Typed>::from_untyped(obj.get(#name.into())?.ok_or_else(|| ErrorKind::NoSuchField(#name.into(), vec![]))?)?564			}565		};566567		quote! {568			#ident: #value,569		}570	}571	fn expand_serialize(&self) -> TokenStream {572		let ident = &self.ident;573		let ty = &self.ty;574		self.name().map_or_else(575			|| {576				if self.is_option {577					quote! {578						if let Some(value) = self.#ident {579							<#ty as TypedObj>::serialize(value, out)?;580						}581					}582				} else {583					quote! {584						<#ty as TypedObj>::serialize(self.#ident, out)?;585					}586				}587			},588			|name| {589				let hide = if self.attr.hide {590					quote! {.hide()}591				} else {592					quote! {}593				};594				let add = if self.attr.add {595					quote! {.add()}596				} else {597					quote! {}598				};599				if self.is_option {600					quote! {601						if let Some(value) = self.#ident {602							out.field(#name)603								#hide604								#add605								.try_value(<#ty as Typed>::into_untyped(value)?)?;606						}607					}608				} else {609					quote! {610						out.field(#name)611							#hide612							#add613							.try_value(<#ty as Typed>::into_untyped(self.#ident)?)?;614					}615				}616			},617		)618	}619}620621#[proc_macro_derive(Typed, attributes(typed))]622pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {623	let input = parse_macro_input!(item as DeriveInput);624625	match derive_typed_inner(input) {626		Ok(v) => v.into(),627		Err(e) => e.to_compile_error().into(),628	}629}630631fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {632	let syn::Data::Struct(data) = &input.data else {633		return Err(Error::new(input.span(), "only structs supported"));634	};635636	let ident = &input.ident;637	let fields = data638		.fields639		.iter()640		.map(TypedField::parse)641		.collect::<Result<Vec<_>>>()?;642643	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();644645	let typed = {646		let fields = fields647			.iter()648			.filter_map(TypedField::expand_field)649			.collect::<Vec<_>>();650		quote! {651			impl #impl_generics Typed for #ident #ty_generics #where_clause {652				const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[653					#(#fields,)*654				]);655656				fn from_untyped(value: Val) -> JrResult<Self> {657					let obj = value.as_obj().expect("shape is correct");658					Self::parse(&obj)659				}660661				fn into_untyped(value: Self) -> JrResult<Val> {662					let mut out = ObjValueBuilder::new();663					value.serialize(&mut out)?;664					Ok(Val::Obj(out.build()))665				}666667			}668		}669	};670671	let fields_parse = fields.iter().map(TypedField::expand_parse);672	let fields_serialize = fields673		.iter()674		.map(TypedField::expand_serialize)675		.collect::<Vec<_>>();676677	Ok(quote! {678		const _: () = {679			use ::jrsonnet_evaluator::{680				typed::{ComplexValType, Typed, TypedObj, CheckType},681				Val, State,682				error::{ErrorKind, Result as JrResult},683				ObjValueBuilder, ObjValue,684			};685686			#typed687688			impl #impl_generics TypedObj for #ident #ty_generics #where_clause {689				fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {690					#(#fields_serialize)*691692					Ok(())693				}694				fn parse(obj: &ObjValue) -> JrResult<Self> {695					Ok(Self {696						#(#fields_parse)*697					})698				}699			}700		};701	})702}703704struct FormatInput {705	formatting: LitStr,706	arguments: Vec<Expr>,707}708impl Parse for FormatInput {709	fn parse(input: ParseStream) -> Result<Self> {710		let formatting = input.parse()?;711		let mut arguments = Vec::new();712713		while input.peek(Token![,]) {714			input.parse::<Token![,]>()?;715			if input.is_empty() {716				// Trailing comma717				break;718			}719			let expr = input.parse()?;720			arguments.push(expr);721		}722723		if !input.is_empty() {724			return Err(syn::Error::new(input.span(), "unexpected trailing input"));725		}726727		Ok(Self {728			formatting,729			arguments,730		})731	}732}733fn is_format_str(i: &str) -> bool {734	let mut is_plain = true;735	// -1 = {736	// +1 = }737	let mut is_bracket = 0i8;738	for ele in i.chars() {739		match ele {740			'{' if is_bracket == -1 => {741				is_bracket = 0;742			}743			'}' if is_bracket == -1 => {744				is_plain = false;745				break;746			}747			'}' if is_bracket == 1 => {748				is_bracket = 0;749			}750			'{' if is_bracket == 1 => {751				is_plain = false;752				break;753			}754			'{' => {755				is_bracket = -1;756			}757			'}' => {758				is_bracket = 1;759			}760			_ if is_bracket != 0 => {761				is_plain = false;762				break;763			}764			_ => {}765		}766	}767	!is_plain || is_bracket != 0768}769impl FormatInput {770	fn expand(self) -> TokenStream {771		let format = self.formatting;772		if is_format_str(&format.value()) {773			let args = self.arguments;774			quote! {775				::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))776			}777		} else {778			if let Some(first) = self.arguments.first() {779				return syn::Error::new(780					first.span(),781					"string has no formatting codes, it should not have the arguments",782				)783				.into_compile_error();784			}785			quote! {786				::jrsonnet_evaluator::IStr::from(#format)787			}788		}789	}790}791792/// `IStr` formatting helper793///794/// Using `format!("literal with no codes").into()` is slower than just `"literal with no codes".into()`795/// This macro looks for formatting codes in the input string, and uses796/// `format!()` only when necessary797#[proc_macro]798pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {799	let input = parse_macro_input!(input as FormatInput);800	input.expand().into()801}