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 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 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 385 386 387 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 411 412 flatten_ok: bool,413 414 add: bool,415 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 517 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 553 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 582 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 593 #[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 772 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 791 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}846847848849850851852#[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}857858859#[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}