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!(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 417 418 flatten_ok: bool,419 420 add: bool,421 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 is_lazy: bool,481}482impl TypedField {483 fn parse(field: &syn::Field) -> Result<Self> {484 let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();485 let Some(ident) = field.ident.clone() else {486 return Err(Error::new(487 field.span(),488 "this field should appear in output object, but it has no visible name",489 ));490 };491 let (is_option, ty) = extract_type_from_option(&field.ty)?492 .map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));493 if is_option && attr.flatten {494 if !attr.flatten_ok {495 return Err(Error::new(496 field.span(),497 "strategy should be set when flattening Option",498 ));499 }500 } else if attr.flatten_ok {501 return Err(Error::new(502 field.span(),503 "flatten(ok) is only useable on optional fields",504 ));505 }506507 let is_lazy = type_is_path(&ty, "Thunk").is_some();508509 Ok(Self {510 attr,511 ident,512 ty,513 is_option,514 is_lazy,515 })516 }517 518 fn name(&self) -> Option<String> {519 if self.attr.flatten {520 return None;521 }522 Some(523 self.attr524 .rename525 .clone()526 .unwrap_or_else(|| self.ident.to_string()),527 )528 }529530 fn expand_field(&self) -> Option<TokenStream> {531 if self.is_option {532 return None;533 }534 let name = self.name()?;535 let ty = &self.ty;536 Some(quote! {537 (#name, <#ty as Typed>::TYPE)538 })539 }540 fn expand_parse(&self) -> TokenStream {541 let ident = &self.ident;542 let ty = &self.ty;543 if self.attr.flatten {544 545 return if self.is_option {546 quote! {547 #ident: <#ty as TypedObj>::parse(&obj).ok(),548 }549 } else {550 quote! {551 #ident: <#ty as TypedObj>::parse(&obj)?,552 }553 };554 };555556 let name = self.name().unwrap();557 let value = if self.is_option {558 quote! {559 if let Some(value) = obj.get(#name.into())? {560 Some(<#ty as Typed>::from_untyped(value)?)561 } else {562 None563 }564 }565 } else {566 quote! {567 <#ty as Typed>::from_untyped(obj.get(#name.into())?.ok_or_else(|| ErrorKind::NoSuchField(#name.into(), vec![]))?)?568 }569 };570571 quote! {572 #ident: #value,573 }574 }575 fn expand_serialize(&self) -> TokenStream {576 let ident = &self.ident;577 let ty = &self.ty;578 self.name().map_or_else(579 || {580 if self.is_option {581 quote! {582 if let Some(value) = self.#ident {583 <#ty as TypedObj>::serialize(value, out)?;584 }585 }586 } else {587 quote! {588 <#ty as TypedObj>::serialize(self.#ident, out)?;589 }590 }591 },592 |name| {593 let hide = if self.attr.hide {594 quote! {.hide()}595 } else {596 quote! {}597 };598 let add = if self.attr.add {599 quote! {.add()}600 } else {601 quote! {}602 };603 let value = if self.is_lazy {604 quote! {605 out.field(#name)606 #hide607 #add608 .try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;609 }610 } else {611 quote! {612 out.field(#name)613 #hide614 #add615 .try_value(<#ty as Typed>::into_untyped(value)?)?;616 }617 };618 if self.is_option {619 quote! {620 if let Some(value) = self.#ident {621 #value622 }623 }624 } else {625 quote! {626 {627 let value = self.#ident;628 #value629 }630 }631 }632 },633 )634 }635}636637#[proc_macro_derive(Typed, attributes(typed))]638pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {639 let input = parse_macro_input!(item as DeriveInput);640641 match derive_typed_inner(input) {642 Ok(v) => v.into(),643 Err(e) => e.to_compile_error().into(),644 }645}646647fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {648 let syn::Data::Struct(data) = &input.data else {649 return Err(Error::new(input.span(), "only structs supported"));650 };651652 let ident = &input.ident;653 let fields = data654 .fields655 .iter()656 .map(TypedField::parse)657 .collect::<Result<Vec<_>>>()?;658659 let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();660661 let typed = {662 let fields = fields663 .iter()664 .filter_map(TypedField::expand_field)665 .collect::<Vec<_>>();666 quote! {667 impl #impl_generics Typed for #ident #ty_generics #where_clause {668 const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[669 #(#fields,)*670 ]);671672 fn from_untyped(value: Val) -> JrResult<Self> {673 let obj = value.as_obj().expect("shape is correct");674 Self::parse(&obj)675 }676677 fn into_untyped(value: Self) -> JrResult<Val> {678 let mut out = ObjValueBuilder::new();679 value.serialize(&mut out)?;680 Ok(Val::Obj(out.build()))681 }682683 }684 }685 };686687 let fields_parse = fields.iter().map(TypedField::expand_parse);688 let fields_serialize = fields689 .iter()690 .map(TypedField::expand_serialize)691 .collect::<Vec<_>>();692693 Ok(quote! {694 const _: () = {695 use ::jrsonnet_evaluator::{696 typed::{ComplexValType, Typed, TypedObj, CheckType},697 Val, State,698 error::{ErrorKind, Result as JrResult},699 ObjValueBuilder, ObjValue,700 };701702 #typed703704 impl #impl_generics TypedObj for #ident #ty_generics #where_clause {705 fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {706 #(#fields_serialize)*707708 Ok(())709 }710 fn parse(obj: &ObjValue) -> JrResult<Self> {711 Ok(Self {712 #(#fields_parse)*713 })714 }715 }716 };717 })718}719720struct FormatInput {721 formatting: LitStr,722 arguments: Vec<Expr>,723}724impl Parse for FormatInput {725 fn parse(input: ParseStream) -> Result<Self> {726 let formatting = input.parse()?;727 let mut arguments = Vec::new();728729 while input.peek(Token![,]) {730 input.parse::<Token![,]>()?;731 if input.is_empty() {732 733 break;734 }735 let expr = input.parse()?;736 arguments.push(expr);737 }738739 if !input.is_empty() {740 return Err(syn::Error::new(input.span(), "unexpected trailing input"));741 }742743 Ok(Self {744 formatting,745 arguments,746 })747 }748}749fn is_format_str(i: &str) -> bool {750 let mut is_plain = true;751 752 753 let mut is_bracket = 0i8;754 for ele in i.chars() {755 match ele {756 '{' if is_bracket == -1 => {757 is_bracket = 0;758 }759 '}' if is_bracket == -1 => {760 is_plain = false;761 break;762 }763 '}' if is_bracket == 1 => {764 is_bracket = 0;765 }766 '{' if is_bracket == 1 => {767 is_plain = false;768 break;769 }770 '{' => {771 is_bracket = -1;772 }773 '}' => {774 is_bracket = 1;775 }776 _ if is_bracket != 0 => {777 is_plain = false;778 break;779 }780 _ => {}781 }782 }783 !is_plain || is_bracket != 0784}785impl FormatInput {786 fn expand(self) -> TokenStream {787 let format = self.formatting;788 if is_format_str(&format.value()) {789 let args = self.arguments;790 quote! {791 ::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))792 }793 } else {794 if let Some(first) = self.arguments.first() {795 return syn::Error::new(796 first.span(),797 "string has no formatting codes, it should not have the arguments",798 )799 .into_compile_error();800 }801 quote! {802 ::jrsonnet_evaluator::IStr::from(#format)803 }804 }805 }806}807808809810811812813#[proc_macro]814pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {815 let input = parse_macro_input!(input as FormatInput);816 input.expand().into()817}818819820#[proc_macro]821#[allow(non_snake_case)]822pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {823 let input = parse_macro_input!(input as ExprClosure);824825 let span = input.inputs.span();826 let move_check = input.capture.is_none().then(|| {827 quote_spanned! {span => {828 compile_error!("Thunk! needs to be called with move closure");829 }}830 });831832 let (env, closure, args) = syn_dissect_closure::split_env(input);833834 let trace_check = args.iter().map(|el| {835 let span = el.span();836 quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}837 });838839 quote! {{840 #move_check841 #(#trace_check)*842 ::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::ThunkValueClosure::new(#env, #closure))843 }}.into()844}