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 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::State::push_description(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::ExprLocation,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}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 514 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 541 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 717 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 736 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}791792793794795796797#[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}