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 EmptyAttr;107impl Parse for EmptyAttr {108 fn parse(_input: ParseStream) -> Result<Self> {109 Ok(Self)110 }111}112113struct BuiltinAttrs {114 fields: Vec<Field>,115}116impl Parse for BuiltinAttrs {117 fn parse(input: ParseStream) -> syn::Result<Self> {118 if input.is_empty() {119 return Ok(Self { fields: Vec::new() });120 }121 input.parse::<kw::fields>()?;122 let fields;123 parenthesized!(fields in input);124 let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;125 Ok(Self {126 fields: p.into_iter().collect(),127 })128 }129}130131enum Optionality {132 Required,133 Optional,134 Default(Expr),135}136137enum ArgInfo {138 Normal {139 ty: Box<Type>,140 optionality: Optionality,141 name: Option<String>,142 cfg_attrs: Vec<Attribute>,143 },144 Lazy {145 is_option: bool,146 name: Option<String>,147 },148 Context,149 Location,150 This,151}152153impl ArgInfo {154 fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {155 let FnArg::Typed(arg) = arg else {156 unreachable!()157 };158 let ident = match &arg.pat as &Pat {159 Pat::Ident(i) => Some(i.ident.clone()),160 _ => None,161 };162 let ty = &arg.ty;163 if type_is_path(ty, "Context").is_some() {164 return Ok(Self::Context);165 } else if type_is_path(ty, "CallLocation").is_some() {166 return Ok(Self::Location);167 } else if type_is_path(ty, "Thunk").is_some() {168 return Ok(Self::Lazy {169 is_option: false,170 name: ident.map(|v| v.to_string()),171 });172 }173174 match ty as &Type {175 Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),176 _ => {}177 }178179 let (optionality, ty) = if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {180 remove_attr(&mut arg.attrs, "default");181 (Optionality::Default(default), ty.clone())182 } else if let Some(ty) = extract_type_from_option(ty)? {183 if type_is_path(ty, "Thunk").is_some() {184 return Ok(Self::Lazy {185 is_option: true,186 name: ident.map(|v| v.to_string()),187 });188 }189190 (Optionality::Optional, Box::new(ty.clone()))191 } else {192 (Optionality::Required, ty.clone())193 };194195 let cfg_attrs = arg196 .attrs197 .iter()198 .filter(|a| a.path().is_ident("cfg"))199 .cloned()200 .collect();201202 Ok(Self::Normal {203 ty,204 optionality,205 name: ident.map(|v| v.to_string()),206 cfg_attrs,207 })208 }209}210211#[proc_macro_attribute]212pub fn builtin(213 attr: proc_macro::TokenStream,214 item: proc_macro::TokenStream,215) -> proc_macro::TokenStream {216 let attr = parse_macro_input!(attr as BuiltinAttrs);217 let item_fn = parse_macro_input!(item as ItemFn);218219 match builtin_inner(attr, item_fn) {220 Ok(v) => v.into(),221 Err(e) => e.into_compile_error().into(),222 }223}224225#[allow(clippy::too_many_lines)]226fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {227 let ReturnType::Type(_, result) = &fun.sig.output else {228 return Err(Error::new(229 fun.sig.span(),230 "builtin should return something",231 ));232 };233234 let name = fun.sig.ident.to_string();235 let args = fun236 .sig237 .inputs238 .iter_mut()239 .map(|arg| ArgInfo::parse(&name, arg))240 .collect::<Result<Vec<_>>>()?;241242 let params_desc = args.iter().filter_map(|a| match a {243 ArgInfo::Normal {244 optionality,245 name,246 cfg_attrs,247 ..248 } => {249 let name = name250 .as_ref()251 .map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});252 let default = match optionality {253 Optionality::Required => quote!(ParamDefault::None),254 Optionality::Optional => quote!(ParamDefault::Exists),255 Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),256 };257 Some(quote! {258 #(#cfg_attrs)*259 BuiltinParam::new(#name, #default),260 })261 }262 ArgInfo::Lazy { is_option, name } => {263 let name = name264 .as_ref()265 .map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});266 Some(quote! {267 BuiltinParam::new(#name, ParamDefault::exists(#is_option)),268 })269 }270 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,271 });272273 let mut id = 0usize;274 let pass = args275 .iter()276 .map(|a| match a {277 ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {278 let cid = id;279 id += 1;280 (quote! {#cid}, a)281 }282 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {283 (quote! {compile_error!("should not use id")}, a)284 }285 })286 .map(|(id, a)| match a {287 ArgInfo::Normal {288 ty,289 optionality,290 name,291 cfg_attrs,292 } => {293 let name = name.as_ref().map_or("<unnamed>", String::as_str);294 let eval = quote! {jrsonnet_evaluator::in_description_frame(295 || format!("argument <{}> evaluation", #name),296 || <#ty>::from_untyped(value.evaluate()?),297 )?};298 let value = match optionality {299 Optionality::Required => quote! {{300 let value = parsed[#id].as_ref().expect("args shape is checked");301 #eval302 },},303 Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {304 Some(#eval)305 } else {306 None307 },},308 Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {309 #eval310 } else {311 let v: #ty = #expr;312 v313 },},314 };315 quote! {316 #(#cfg_attrs)*317 #value318 }319 }320 ArgInfo::Lazy { is_option, .. } => {321 if *is_option {322 quote! {if let Some(value) = &parsed[#id] {323 Some(value.clone())324 } else {325 None326 },}327 } else {328 quote! {329 parsed[#id].as_ref().expect("args shape is correct").clone(),330 }331 }332 }333 ArgInfo::Context => quote! {ctx.clone(),},334 ArgInfo::Location => quote! {location,},335 ArgInfo::This => quote! {self,},336 });337338 let fields = attr.fields.iter().map(|field| {339 let attrs = &field.attrs;340 let name = &field.name;341 let ty = &field.ty;342 quote! {343 #(#attrs)*344 pub #name: #ty,345 }346 });347348 let name = &fun.sig.ident;349 let vis = &fun.vis;350 let static_ext = if attr.fields.is_empty() {351 quote! {352 impl #name {353 pub const INST: &'static dyn StaticBuiltin = &#name {};354 }355 impl StaticBuiltin for #name {}356 }357 } else {358 quote! {}359 };360 let static_derive_copy = if attr.fields.is_empty() {361 quote! {, Copy}362 } else {363 quote! {}364 };365366 Ok(quote! {367 #fun368369 #[doc(hidden)]370 #[allow(non_camel_case_types)]371 #[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]372 #vis struct #name {373 #(#fields)*374 }375 const _: () = {376 use ::jrsonnet_evaluator::{377 State, Val,378 function::{builtin::{Builtin, StaticBuiltin, BuiltinParam, ParamName, ParamDefault}, CallLocation, ArgsLike, parse::parse_builtin_call},379 Result, Context, typed::Typed,380 parser::Span,381 };382 const PARAMS: &'static [BuiltinParam] = &[383 #(#params_desc)*384 ];385386 #static_ext387 impl Builtin for #name388 where389 Self: 'static390 {391 fn name(&self) -> &str {392 stringify!(#name)393 }394 fn params(&self) -> &[BuiltinParam] {395 PARAMS396 }397 #[allow(unused_variables)]398 fn call(&self, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {399 let parsed = parse_builtin_call(ctx.clone(), &PARAMS, args, false)?;400401 let result: #result = #name(#(#pass)*);402 <_ as Typed>::into_result(result)403 }404 fn as_any(&self) -> &dyn ::std::any::Any {405 self406 }407 }408 };409 })410}411412#[derive(Default)]413#[allow(clippy::struct_excessive_bools)]414struct TypedAttr {415 rename: Option<String>,416 aliases: Vec<String>,417 flatten: bool,418 419 420 flatten_ok: bool,421 422 add: bool,423 424 hide: bool,425}426impl Parse for TypedAttr {427 fn parse(input: ParseStream) -> syn::Result<Self> {428 let mut out = Self::default();429 loop {430 let lookahead = input.lookahead1();431 if lookahead.peek(kw::rename) {432 input.parse::<kw::rename>()?;433 input.parse::<Token![=]>()?;434 let name = input.parse::<LitStr>()?;435 if out.rename.is_some() {436 return Err(Error::new(437 name.span(),438 "rename attribute may only be specified once",439 ));440 }441 out.rename = Some(name.value());442 } else if lookahead.peek(kw::alias) {443 input.parse::<kw::alias>()?;444 input.parse::<Token![=]>()?;445 let alias = input.parse::<LitStr>()?;446 out.aliases.push(alias.value());447 } else if lookahead.peek(kw::flatten) {448 input.parse::<kw::flatten>()?;449 out.flatten = true;450 if input.peek(token::Paren) {451 let content;452 parenthesized!(content in input);453 let lookahead = content.lookahead1();454 if lookahead.peek(kw::ok) {455 content.parse::<kw::ok>()?;456 out.flatten_ok = true;457 } else {458 return Err(lookahead.error());459 }460 }461 } else if lookahead.peek(kw::add) {462 input.parse::<kw::add>()?;463 out.add = true;464 } else if lookahead.peek(kw::hide) {465 input.parse::<kw::hide>()?;466 out.hide = true;467 } else if input.is_empty() {468 break;469 } else {470 return Err(lookahead.error());471 }472 if input.peek(Token![,]) {473 input.parse::<Token![,]>()?;474 } else {475 break;476 }477 }478 Ok(out)479 }480}481482struct TypedField {483 attr: TypedAttr,484 ident: Ident,485 ty: Type,486 is_option: bool,487 is_lazy: bool,488}489impl TypedField {490 fn parse(field: &syn::Field) -> Result<Self> {491 let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();492 let Some(ident) = field.ident.clone() else {493 return Err(Error::new(494 field.span(),495 "this field should appear in output object, but it has no visible name",496 ));497 };498 let (is_option, ty) = extract_type_from_option(&field.ty)?499 .map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));500 if is_option && attr.flatten {501 if !attr.flatten_ok {502 return Err(Error::new(503 field.span(),504 "strategy should be set when flattening Option",505 ));506 }507 } else if attr.flatten_ok {508 return Err(Error::new(509 field.span(),510 "flatten(ok) is only useable on optional fields",511 ));512 }513514 let is_lazy = type_is_path(&ty, "Thunk").is_some();515516 Ok(Self {517 attr,518 ident,519 ty,520 is_option,521 is_lazy,522 })523 }524 525 fn name(&self) -> Option<String> {526 if self.attr.flatten {527 return None;528 }529 Some(530 self.attr531 .rename532 .clone()533 .unwrap_or_else(|| self.ident.to_string()),534 )535 }536537 fn expand_field(&self) -> Option<TokenStream> {538 if self.is_option {539 return None;540 }541 let name = self.name()?;542 let ty = &self.ty;543 Some(quote! {544 (#name, <#ty as Typed>::TYPE)545 })546 }547548 fn expand_parse(&self) -> TokenStream {549 if self.is_option {550 self.expand_parse_optional()551 } else {552 self.expand_parse_mandatory()553 }554 }555556 fn expand_parse_optional(&self) -> TokenStream {557 let ident = &self.ident;558 let ty = &self.ty;559560 561 if self.attr.flatten {562 return quote! {563 #ident: <#ty as TypedObj>::parse(&obj).ok(),564 };565 }566567 let name = self.name().unwrap();568 let aliases = &self.attr.aliases;569570 quote! {571 #ident: {572 let __value = if let Some(__v) = obj.get(#name.into())? {573 Some(__v)574 } #(else if let Some(__v) = obj.get(#aliases.into())? {575 Some(__v)576 })* else {577 None578 };579580 __value.map(<#ty as Typed>::from_untyped).transpose()?581 },582 }583 }584585 fn expand_parse_mandatory(&self) -> TokenStream {586 let ident = &self.ident;587 let ty = &self.ty;588589 590 if self.attr.flatten {591 return quote! {592 #ident: <#ty as TypedObj>::parse(&obj)?,593 };594 }595596 let name = self.name().unwrap();597 let aliases = &self.attr.aliases;598599 let error_text = if aliases.is_empty() {600 601 #[allow(clippy::redundant_clone)]602 name.clone()603 } else {604 format!("{name} (alias {})", aliases.join(", "))605 };606607 quote! {608 #ident: {609 let __value = if let Some(__v) = obj.get(#name.into())? {610 __v611 } #(else if let Some(__v) = obj.get(#aliases.into())? {612 __v613 })* else {614 return Err(ErrorKind::NoSuchField(#error_text.into(), vec![]).into());615 };616617 <#ty as Typed>::from_untyped(__value)?618 },619 }620 }621622 fn expand_serialize(&self) -> TokenStream {623 let ident = &self.ident;624 let ty = &self.ty;625 self.name().map_or_else(626 || {627 if self.is_option {628 quote! {629 if let Some(value) = self.#ident {630 <#ty as TypedObj>::serialize(value, out)?;631 }632 }633 } else {634 quote! {635 <#ty as TypedObj>::serialize(self.#ident, out)?;636 }637 }638 },639 |name| {640 let hide = if self.attr.hide {641 quote! {.hide()}642 } else {643 quote! {}644 };645 let add = if self.attr.add {646 quote! {.add()}647 } else {648 quote! {}649 };650 let value = if self.is_lazy {651 quote! {652 out.field(#name)653 #hide654 #add655 .try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;656 }657 } else {658 quote! {659 out.field(#name)660 #hide661 #add662 .try_value(<#ty as Typed>::into_untyped(value)?)?;663 }664 };665 if self.is_option {666 quote! {667 if let Some(value) = self.#ident {668 #value669 }670 }671 } else {672 quote! {673 {674 let value = self.#ident;675 #value676 }677 }678 }679 },680 )681 }682}683684#[proc_macro_derive(Typed, attributes(typed))]685pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {686 let input = parse_macro_input!(item as DeriveInput);687688 match derive_typed_inner(input) {689 Ok(v) => v.into(),690 Err(e) => e.to_compile_error().into(),691 }692}693694fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {695 let syn::Data::Struct(data) = &input.data else {696 return Err(Error::new(input.span(), "only structs supported"));697 };698699 let ident = &input.ident;700 let fields = data701 .fields702 .iter()703 .map(TypedField::parse)704 .collect::<Result<Vec<_>>>()?;705706 let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();707708 let typed = {709 let fields = fields710 .iter()711 .filter_map(TypedField::expand_field)712 .collect::<Vec<_>>();713 quote! {714 impl #impl_generics Typed for #ident #ty_generics #where_clause {715 const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[716 #(#fields,)*717 ]);718719 fn from_untyped(value: Val) -> JrResult<Self> {720 let obj = value.as_obj().expect("shape is correct");721 Self::parse(&obj)722 }723724 fn into_untyped(value: Self) -> JrResult<Val> {725 let mut out = ObjValueBuilder::new();726 value.serialize(&mut out)?;727 Ok(Val::Obj(out.build()))728 }729730 }731 }732 };733734 let fields_parse = fields.iter().map(TypedField::expand_parse);735 let fields_serialize = fields736 .iter()737 .map(TypedField::expand_serialize)738 .collect::<Vec<_>>();739740 Ok(quote! {741 const _: () = {742 use ::jrsonnet_evaluator::{743 typed::{ComplexValType, Typed, TypedObj, CheckType},744 Val, State,745 error::{ErrorKind, Result as JrResult},746 ObjValueBuilder, ObjValue,747 };748749 #typed750751 impl #impl_generics TypedObj for #ident #ty_generics #where_clause {752 fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {753 #(#fields_serialize)*754755 Ok(())756 }757 fn parse(obj: &ObjValue) -> JrResult<Self> {758 Ok(Self {759 #(#fields_parse)*760 })761 }762 }763 };764 })765}766767struct FormatInput {768 formatting: LitStr,769 arguments: Vec<Expr>,770}771impl Parse for FormatInput {772 fn parse(input: ParseStream) -> Result<Self> {773 let formatting = input.parse()?;774 let mut arguments = Vec::new();775776 while input.peek(Token![,]) {777 input.parse::<Token![,]>()?;778 if input.is_empty() {779 780 break;781 }782 let expr = input.parse()?;783 arguments.push(expr);784 }785786 if !input.is_empty() {787 return Err(syn::Error::new(input.span(), "unexpected trailing input"));788 }789790 Ok(Self {791 formatting,792 arguments,793 })794 }795}796fn is_format_str(i: &str) -> bool {797 let mut is_plain = true;798 799 800 let mut is_bracket = 0i8;801 for ele in i.chars() {802 match ele {803 '{' if is_bracket == -1 => {804 is_bracket = 0;805 }806 '}' if is_bracket == -1 => {807 is_plain = false;808 break;809 }810 '}' if is_bracket == 1 => {811 is_bracket = 0;812 }813 '{' if is_bracket == 1 => {814 is_plain = false;815 break;816 }817 '{' => {818 is_bracket = -1;819 }820 '}' => {821 is_bracket = 1;822 }823 _ if is_bracket != 0 => {824 is_plain = false;825 break;826 }827 _ => {}828 }829 }830 !is_plain || is_bracket != 0831}832impl FormatInput {833 fn expand(self) -> TokenStream {834 let format = self.formatting;835 if is_format_str(&format.value()) {836 let args = self.arguments;837 quote! {838 ::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))839 }840 } else {841 if let Some(first) = self.arguments.first() {842 return syn::Error::new(843 first.span(),844 "string has no formatting codes, it should not have the arguments",845 )846 .into_compile_error();847 }848 quote! {849 ::jrsonnet_evaluator::IStr::from(#format)850 }851 }852 }853}854855856857858859860#[proc_macro]861pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {862 let input = parse_macro_input!(input as FormatInput);863 input.expand().into()864}865866867#[proc_macro]868#[allow(non_snake_case)]869pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {870 let input = parse_macro_input!(input as ExprClosure);871872 let span = input.inputs.span();873 let move_check = input.capture.is_none().then(|| {874 quote_spanned! {span => {875 compile_error!("Thunk! needs to be called with move closure");876 }}877 });878879 let (env, closure, args) = syn_dissect_closure::split_env(input);880881 let trace_check = args.iter().map(|el| {882 let span = el.span();883 quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}884 });885886 quote! {{887 #move_check888 #(#trace_check)*889 ::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::ThunkValueClosure::new(#env, #closure))890 }}.into()891}