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

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::Comma,12	Attribute, DeriveInput, Error, Expr, ExprClosure, FnArg, GenericArgument, Ident, ItemFn,13	LitStr, Meta, Pat, Path, PathArguments, Result, ReturnType, Token, Type,14};1516use self::typed::{derive_from_untyped_inner, derive_into_untyped_inner, derive_typed_inner};1718mod names;19mod typed;2021fn try_parse_attr_noargs<I>(attrs: &[Attribute], ident: I) -> Result<bool>22where23	Ident: PartialEq<I>,24{25	let attrs = attrs26		.iter()27		.filter(|a| a.path().is_ident(&ident))28		.collect::<Vec<_>>();29	if attrs.len() > 1 {30		return Err(Error::new(31			attrs[1].span(),32			"this attribute may be specified only once",33		));34	} else if attrs.is_empty() {35		return Ok(false);36	}37	let attr = attrs[0];3839	match attr.meta {40		Meta::Path(_) => Ok(true),41		_ => Ok(false),42	}43}44fn parse_attr<A: Parse, I>(attrs: &[Attribute], ident: I) -> Result<Option<A>>45where46	Ident: PartialEq<I>,47{48	let attrs = attrs49		.iter()50		.filter(|a| a.path().is_ident(&ident))51		.collect::<Vec<_>>();52	if attrs.len() > 1 {53		return Err(Error::new(54			attrs[1].span(),55			"this attribute may be specified only once",56		));57	} else if attrs.is_empty() {58		return Ok(None);59	}60	let attr = attrs[0];61	let attr = attr.parse_args::<A>()?;6263	Ok(Some(attr))64}65fn remove_attr<I>(attrs: &mut Vec<Attribute>, ident: I)66where67	Ident: PartialEq<I>,68{69	attrs.retain(|a| !a.path().is_ident(&ident));70}7172fn path_is(path: &Path, needed: &str) -> bool {73	path.leading_colon.is_none()74		&& !path.segments.is_empty()75		&& path.segments.iter().last().unwrap().ident == needed76}7778fn type_is_path<'ty>(ty: &'ty Type, needed: &str) -> Option<&'ty PathArguments> {79	match ty {80		Type::Path(path) if path.qself.is_none() && path_is(&path.path, needed) => {81			let args = &path.path.segments.iter().last().unwrap().arguments;82			Some(args)83		}84		_ => None,85	}86}8788fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {89	let Some(args) = type_is_path(ty, "Option") else {90		return Ok(None);91	};92	// It should have only on angle-bracketed param ("<String>"):93	let PathArguments::AngleBracketed(params) = args else {94		return Err(Error::new(args.span(), "missing option generic"));95	};96	let generic_arg = params.args.iter().next().unwrap();97	// This argument must be a type:98	let GenericArgument::Type(ty) = generic_arg else {99		return Err(Error::new(100			generic_arg.span(),101			"option generic should be a type",102		));103	};104	Ok(Some(ty))105}106107struct Field {108	attrs: Vec<Attribute>,109	name: Ident,110	_colon: Token![:],111	ty: Type,112}113impl Parse for Field {114	fn parse(input: ParseStream) -> syn::Result<Self> {115		Ok(Self {116			attrs: input.call(Attribute::parse_outer)?,117			name: input.parse()?,118			_colon: input.parse()?,119			ty: input.parse()?,120		})121	}122}123124mod kw {125	syn::custom_keyword!(fields);126	syn::custom_keyword!(rename);127	syn::custom_keyword!(alias);128	syn::custom_keyword!(flatten);129	syn::custom_keyword!(add);130	syn::custom_keyword!(hide);131	syn::custom_keyword!(ok);132}133134struct BuiltinAttrs {135	fields: Vec<Field>,136}137impl Parse for BuiltinAttrs {138	fn parse(input: ParseStream) -> syn::Result<Self> {139		if input.is_empty() {140			return Ok(Self { fields: Vec::new() });141		}142		input.parse::<kw::fields>()?;143		let fields;144		parenthesized!(fields in input);145		let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;146		Ok(Self {147			fields: p.into_iter().collect(),148		})149	}150}151152enum Optionality {153	Required,154	Optional,155	Default(Expr),156	TypeDefault,157}158159#[allow(160	clippy::large_enum_variant,161	reason = "this macro is not that hot for it to matter"162)]163enum ArgInfo {164	Normal {165		ty: Box<Type>,166		optionality: Optionality,167		name: Option<String>,168		cfg_attrs: Vec<Attribute>,169	},170	Lazy {171		is_option: bool,172		name: Option<String>,173	},174	Context,175	Location,176	This,177}178179impl ArgInfo {180	fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {181		let FnArg::Typed(arg) = arg else {182			unreachable!()183		};184		let ident = match &arg.pat as &Pat {185			Pat::Ident(i) => Some(i.ident.clone()),186			_ => None,187		};188		let ty = &arg.ty;189		if type_is_path(ty, "Context").is_some() {190			return Ok(Self::Context);191		} else if type_is_path(ty, "CallLocation").is_some() {192			return Ok(Self::Location);193		} else if type_is_path(ty, "Thunk").is_some() {194			return Ok(Self::Lazy {195				is_option: false,196				name: ident.map(|v| v.to_string()),197			});198		}199200		match ty as &Type {201			Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),202			_ => {}203		}204205		let (optionality, ty) = if try_parse_attr_noargs(&arg.attrs, "default")? {206			remove_attr(&mut arg.attrs, "default");207			(Optionality::TypeDefault, ty.clone())208		} else if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {209			remove_attr(&mut arg.attrs, "default");210			(Optionality::Default(default), ty.clone())211		} else if let Some(ty) = extract_type_from_option(ty)? {212			if type_is_path(ty, "Thunk").is_some() {213				return Ok(Self::Lazy {214					is_option: true,215					name: ident.map(|v| v.to_string()),216				});217			}218219			(Optionality::Optional, Box::new(ty.clone()))220		} else {221			(Optionality::Required, ty.clone())222		};223224		let cfg_attrs = arg225			.attrs226			.iter()227			.filter(|a| a.path().is_ident("cfg"))228			.cloned()229			.collect();230231		Ok(Self::Normal {232			ty,233			optionality,234			name: ident.map(|v| v.to_string()),235			cfg_attrs,236		})237	}238}239240#[proc_macro_attribute]241pub fn builtin(242	attr: proc_macro::TokenStream,243	item: proc_macro::TokenStream,244) -> proc_macro::TokenStream {245	let attr = parse_macro_input!(attr as BuiltinAttrs);246	let item_fn = parse_macro_input!(item as ItemFn);247248	match builtin_inner(attr, item_fn) {249		Ok(v) => v.into(),250		Err(e) => e.into_compile_error().into(),251	}252}253254#[allow(clippy::too_many_lines)]255fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {256	let ReturnType::Type(_, result) = &fun.sig.output else {257		return Err(Error::new(258			fun.sig.span(),259			"builtin should return something",260		));261	};262263	let name = fun.sig.ident.to_string();264	let args = fun265		.sig266		.inputs267		.iter_mut()268		.map(|arg| ArgInfo::parse(&name, arg))269		.collect::<Result<Vec<_>>>()?;270271	let params_desc = args.iter().filter_map(|a| match a {272		ArgInfo::Normal {273			optionality,274			name,275			cfg_attrs,276			..277		} => {278			let name = name279				.as_ref()280				.map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});281			let default = match optionality {282				Optionality::Required => quote!(ParamDefault::None),283				Optionality::Optional | Optionality::TypeDefault => quote!(ParamDefault::Exists),284				Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),285			};286			Some(quote! {287				#(#cfg_attrs)*288				[#name => #default],289			})290		}291		ArgInfo::Lazy { is_option, name } => {292			let name = name293				.as_ref()294				.map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});295			Some(quote! {296				[#name => ParamDefault::exists(#is_option)],297			})298		}299		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,300	});301302	let mut id = 0usize;303	let pass = args304		.iter()305		.map(|a| match a {306			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {307				let cid = id;308				id += 1;309				(quote! {#cid}, a)310			}311			ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {312				(quote! {compile_error!("should not use id")}, a)313			}314		})315		.map(|(id, a)| match a {316			ArgInfo::Normal {317				ty,318				optionality,319				name,320				cfg_attrs,321			} => {322				let name = name.as_ref().map_or("<unnamed>", String::as_str);323				let eval = quote! {jrsonnet_evaluator::in_description_frame(324					|| format!("argument <{}> evaluation", #name),325					|| <#ty as FromUntyped>::from_untyped(value.evaluate()?),326				)?};327				let value = match optionality {328					Optionality::Required => quote! {{329						let value = parsed[#id].as_ref().expect("args shape is checked");330						#eval331					},},332					Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {333						Some(#eval)334					} else {335						None336					},},337					Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {338						#eval339					} else {340						let v: #ty = #expr;341						v342					},},343					Optionality::TypeDefault => quote! {if let Some(value) = &parsed[#id] {344						#eval345					} else {346						let v: #ty = Default::default();347						v348					},},349				};350				quote! {351					#(#cfg_attrs)*352					#value353				}354			}355			ArgInfo::Lazy { is_option, .. } => {356				if *is_option {357					quote! {if let Some(value) = &parsed[#id] {358						Some(value.clone())359					} else {360						None361					},}362				} else {363					quote! {364						parsed[#id].as_ref().expect("args shape is correct").clone(),365					}366				}367			}368			ArgInfo::Context => quote! {ctx.clone(),},369			ArgInfo::Location => quote! {location,},370			ArgInfo::This => quote! {self,},371		});372373	let fields = attr.fields.iter().map(|field| {374		let attrs = &field.attrs;375		let name = &field.name;376		let ty = &field.ty;377		quote! {378			#(#attrs)*379			pub #name: #ty,380		}381	});382383	let name = &fun.sig.ident;384	let vis = &fun.vis;385	let static_ext = if attr.fields.is_empty() {386		quote! {387			impl #name {388				pub const INST: &'static dyn StaticBuiltin = &#name {};389			}390			impl StaticBuiltin for #name {}391		}392	} else {393		quote! {}394	};395	let static_derive_copy = if attr.fields.is_empty() {396		quote! {, Copy}397	} else {398		quote! {}399	};400401	Ok(quote! {402		#fun403404		#[doc(hidden)]405		#[allow(non_camel_case_types)]406		#[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]407		#vis struct #name {408			#(#fields)*409		}410		const _: () = {411			use ::jrsonnet_evaluator::{412				State, Val,413				function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation},414				Result, Context, typed::{Typed, FromUntyped, IntoUntypedResult},415				parser::Span, params, Thunk,416			};417			params!(418				#(#params_desc)*419			);420421			#static_ext422			impl Builtin for #name423			where424				Self: 'static425			{426				fn name(&self) -> &str {427					stringify!(#name)428				}429				fn params(&self) -> FunctionSignature {430					PARAMS.with(|p| p.clone())431				}432				#[allow(unused_variables)]433				fn call(&self, location: CallLocation<'_>, parsed: &[Option<Thunk<Val>>]) -> Result<Val> {434					let result: #result = #name(#(#pass)*);435					<_ as IntoUntypedResult>::into_untyped_result(result)436				}437				fn as_any(&self) -> &dyn ::std::any::Any {438					self439				}440			}441		};442	})443}444445#[proc_macro_derive(Typed, attributes(typed))]446pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {447	let input = parse_macro_input!(item as DeriveInput);448449	match derive_typed_inner(input) {450		Ok(v) => v.into(),451		Err(e) => e.to_compile_error().into(),452	}453}454#[proc_macro_derive(IntoUntyped, attributes(typed))]455pub fn derive_into_untyped(item: proc_macro::TokenStream) -> proc_macro::TokenStream {456	let input = parse_macro_input!(item as DeriveInput);457458	match derive_into_untyped_inner(input) {459		Ok(v) => v.into(),460		Err(e) => e.to_compile_error().into(),461	}462}463#[proc_macro_derive(FromUntyped, attributes(typed))]464pub fn derive_from_untyped(item: proc_macro::TokenStream) -> proc_macro::TokenStream {465	let input = parse_macro_input!(item as DeriveInput);466467	match derive_from_untyped_inner(input) {468		Ok(v) => v.into(),469		Err(e) => e.to_compile_error().into(),470	}471}472473struct FormatInput {474	formatting: LitStr,475	arguments: Vec<Expr>,476}477impl Parse for FormatInput {478	fn parse(input: ParseStream) -> Result<Self> {479		let formatting = input.parse()?;480		let mut arguments = Vec::new();481482		while input.peek(Token![,]) {483			input.parse::<Token![,]>()?;484			if input.is_empty() {485				// Trailing comma486				break;487			}488			let expr = input.parse()?;489			arguments.push(expr);490		}491492		if !input.is_empty() {493			return Err(syn::Error::new(input.span(), "unexpected trailing input"));494		}495496		Ok(Self {497			formatting,498			arguments,499		})500	}501}502fn is_format_str(i: &str) -> bool {503	let mut is_plain = true;504	// -1 = {505	// +1 = }506	let mut is_bracket = 0i8;507	for ele in i.chars() {508		match ele {509			'{' if is_bracket == -1 => {510				is_bracket = 0;511			}512			'}' if is_bracket == -1 => {513				is_plain = false;514				break;515			}516			'}' if is_bracket == 1 => {517				is_bracket = 0;518			}519			'{' if is_bracket == 1 => {520				is_plain = false;521				break;522			}523			'{' => {524				is_bracket = -1;525			}526			'}' => {527				is_bracket = 1;528			}529			_ if is_bracket != 0 => {530				is_plain = false;531				break;532			}533			_ => {}534		}535	}536	!is_plain || is_bracket != 0537}538impl FormatInput {539	fn expand(self) -> TokenStream {540		let format = self.formatting;541		if is_format_str(&format.value()) {542			let args = self.arguments;543			quote! {544				::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))545			}546		} else {547			if let Some(first) = self.arguments.first() {548				return syn::Error::new(549					first.span(),550					"string has no formatting codes, it should not have the arguments",551				)552				.into_compile_error();553			}554			quote! {555				::jrsonnet_evaluator::IStr::from(#format)556			}557		}558	}559}560561/// `IStr` formatting helper562///563/// Using `format!("literal with no codes").into()` is slower than just `"literal with no codes".into()`564/// This macro looks for formatting codes in the input string, and uses565/// `format!()` only when necessary566#[proc_macro]567pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {568	let input = parse_macro_input!(input as FormatInput);569	input.expand().into()570}571572/// Create Thunk using closure syntax573#[proc_macro]574#[allow(non_snake_case)]575pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {576	let input = parse_macro_input!(input as ExprClosure);577578	let span = input.inputs.span();579	let move_check = input.capture.is_none().then(|| {580		quote_spanned! {span => {581			compile_error!("Thunk! needs to be called with move closure");582		}}583	});584585	let (env, closure, args) = syn_dissect_closure::split_env(input);586587	let trace_check = args.iter().map(|el| {588		let span = el.span();589		quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}590	});591592	quote! {{593		#move_check594		#(#trace_check)*595		::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))596	}}.into()597}