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 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 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!(method);132 syn::custom_keyword!(ok);133}134135struct BuiltinAttrs {136 fields: Vec<Field>,137}138impl Parse for BuiltinAttrs {139 fn parse(input: ParseStream) -> syn::Result<Self> {140 if input.is_empty() {141 return Ok(Self { fields: Vec::new() });142 }143 input.parse::<kw::fields>()?;144 let fields;145 parenthesized!(fields in input);146 let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;147 Ok(Self {148 fields: p.into_iter().collect(),149 })150 }151}152153enum Optionality {154 Required,155 Optional,156 Default(Expr),157 TypeDefault,158}159160#[allow(161 clippy::large_enum_variant,162 reason = "this macro is not that hot for it to matter"163)]164enum ArgInfo {165 Normal {166 ty: Box<Type>,167 optionality: Optionality,168 name: Option<String>,169 cfg_attrs: Vec<Attribute>,170 },171 Lazy {172 is_option: bool,173 name: Option<String>,174 },175 Context,176 Location,177 This,178}179180impl ArgInfo {181 fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {182 let FnArg::Typed(arg) = arg else {183 unreachable!()184 };185 let ident = match &arg.pat as &Pat {186 Pat::Ident(i) => Some(i.ident.clone()),187 _ => None,188 };189 let ty = &arg.ty;190 if type_is_path(ty, "Context").is_some() {191 return Ok(Self::Context);192 } else if type_is_path(ty, "CallLocation").is_some() {193 return Ok(Self::Location);194 } else if type_is_path(ty, "Thunk").is_some() {195 return Ok(Self::Lazy {196 is_option: false,197 name: ident.map(|v| v.to_string()),198 });199 }200201 match ty as &Type {202 Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),203 _ => {}204 }205206 let (optionality, ty) = if try_parse_attr_noargs(&arg.attrs, "default")? {207 remove_attr(&mut arg.attrs, "default");208 (Optionality::TypeDefault, ty.clone())209 } else if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {210 remove_attr(&mut arg.attrs, "default");211 (Optionality::Default(default), ty.clone())212 } else if let Some(ty) = extract_type_from_option(ty)? {213 if type_is_path(ty, "Thunk").is_some() {214 return Ok(Self::Lazy {215 is_option: true,216 name: ident.map(|v| v.to_string()),217 });218 }219220 (Optionality::Optional, Box::new(ty.clone()))221 } else {222 (Optionality::Required, ty.clone())223 };224225 let cfg_attrs = arg226 .attrs227 .iter()228 .filter(|a| a.path().is_ident("cfg"))229 .cloned()230 .collect();231232 Ok(Self::Normal {233 ty,234 optionality,235 name: ident.map(|v| v.to_string()),236 cfg_attrs,237 })238 }239}240241#[proc_macro_attribute]242pub fn builtin(243 attr: proc_macro::TokenStream,244 item: proc_macro::TokenStream,245) -> proc_macro::TokenStream {246 let attr = parse_macro_input!(attr as BuiltinAttrs);247 let item_fn = parse_macro_input!(item as ItemFn);248249 match builtin_inner(attr, item_fn) {250 Ok(v) => v.into(),251 Err(e) => e.into_compile_error().into(),252 }253}254255#[allow(clippy::too_many_lines)]256fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {257 let ReturnType::Type(_, result) = &fun.sig.output else {258 return Err(Error::new(259 fun.sig.span(),260 "builtin should return something",261 ));262 };263264 let name = fun.sig.ident.to_string();265 let args = fun266 .sig267 .inputs268 .iter_mut()269 .map(|arg| ArgInfo::parse(&name, arg))270 .collect::<Result<Vec<_>>>()?;271272 let params_desc = args.iter().filter_map(|a| match a {273 ArgInfo::Normal {274 optionality,275 name,276 cfg_attrs,277 ..278 } => {279 let name = name280 .as_ref()281 .map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});282 let default = match optionality {283 Optionality::Required => quote!(ParamDefault::None),284 Optionality::Optional | Optionality::TypeDefault => quote!(ParamDefault::Exists),285 Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),286 };287 Some(quote! {288 #(#cfg_attrs)*289 [#name => #default],290 })291 }292 ArgInfo::Lazy { is_option, name } => {293 let name = name294 .as_ref()295 .map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});296 Some(quote! {297 [#name => ParamDefault::exists(#is_option)],298 })299 }300 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,301 });302303 let mut id = 0usize;304 let pass = args305 .iter()306 .map(|a| match a {307 ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {308 let cid = id;309 id += 1;310 (quote! {#cid}, a)311 }312 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {313 (quote! {compile_error!("should not use id")}, a)314 }315 })316 .map(|(id, a)| match a {317 ArgInfo::Normal {318 ty,319 optionality,320 name,321 cfg_attrs,322 } => {323 let name = name.as_ref().map_or("<unnamed>", String::as_str);324 let eval = quote! {jrsonnet_evaluator::in_description_frame(325 || format!("argument <{}> evaluation", #name),326 || <#ty as FromUntyped>::from_untyped(value.evaluate()?),327 )?};328 let value = match optionality {329 Optionality::Required => quote! {{330 let value = parsed[#id].as_ref().expect("args shape is checked");331 #eval332 },},333 Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {334 Some(#eval)335 } else {336 None337 },},338 Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {339 #eval340 } else {341 let v: #ty = #expr;342 v343 },},344 Optionality::TypeDefault => quote! {if let Some(value) = &parsed[#id] {345 #eval346 } else {347 let v: #ty = Default::default();348 v349 },},350 };351 quote! {352 #(#cfg_attrs)*353 #value354 }355 }356 ArgInfo::Lazy { is_option, .. } => {357 if *is_option {358 quote! {if let Some(value) = &parsed[#id] {359 Some(value.clone())360 } else {361 None362 },}363 } else {364 quote! {365 parsed[#id].as_ref().expect("args shape is correct").clone(),366 }367 }368 }369 ArgInfo::Context => quote! {ctx.clone(),},370 ArgInfo::Location => quote! {location,},371 ArgInfo::This => quote! {self,},372 });373374 let fields = attr.fields.iter().map(|field| {375 let attrs = &field.attrs;376 let name = &field.name;377 let ty = &field.ty;378 quote! {379 #(#attrs)*380 pub #name: #ty,381 }382 });383384 let name = &fun.sig.ident;385 let vis = &fun.vis;386 let static_derive_copy = if attr.fields.is_empty() {387 quote! {, Copy, Default}388 } else {389 quote! {}390 };391392 Ok(quote! {393 #fun394395 #[doc(hidden)]396 #[allow(non_camel_case_types)]397 #[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]398 #vis struct #name {399 #(#fields)*400 }401 const _: () = {402 use ::jrsonnet_evaluator::{403 State, Val,404 function::{builtin::Builtin, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation},405 Result, Context, typed::{Typed, FromUntyped, IntoUntypedResult},406 Span, params, Thunk,407 };408 params!(409 #(#params_desc)*410 );411412 impl Builtin for #name413 where414 Self: 'static415 {416 fn name(&self) -> &str {417 stringify!(#name)418 }419 fn params(&self) -> FunctionSignature {420 PARAMS.with(|p| p.clone())421 }422 #[allow(unused_variables)]423 fn call(&self, location: CallLocation<'_>, parsed: &[Option<Thunk<Val>>]) -> Result<Val> {424 let result: #result = #name(#(#pass)*);425 <_ as IntoUntypedResult>::into_untyped_result(result)426 }427 fn as_any(&self) -> &dyn ::std::any::Any {428 self429 }430 }431 };432 })433}434435#[proc_macro_derive(Typed, attributes(typed))]436pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {437 let input = parse_macro_input!(item as DeriveInput);438439 match derive_typed_inner(input) {440 Ok(v) => v.into(),441 Err(e) => e.to_compile_error().into(),442 }443}444#[proc_macro_derive(IntoUntyped, attributes(typed))]445pub fn derive_into_untyped(item: proc_macro::TokenStream) -> proc_macro::TokenStream {446 let input = parse_macro_input!(item as DeriveInput);447448 match derive_into_untyped_inner(input) {449 Ok(v) => v.into(),450 Err(e) => e.to_compile_error().into(),451 }452}453#[proc_macro_derive(FromUntyped, attributes(typed))]454pub fn derive_from_untyped(item: proc_macro::TokenStream) -> proc_macro::TokenStream {455 let input = parse_macro_input!(item as DeriveInput);456457 match derive_from_untyped_inner(input) {458 Ok(v) => v.into(),459 Err(e) => e.to_compile_error().into(),460 }461}462463struct FormatInput {464 formatting: LitStr,465 arguments: Vec<Expr>,466}467impl Parse for FormatInput {468 fn parse(input: ParseStream) -> Result<Self> {469 let formatting = input.parse()?;470 let mut arguments = Vec::new();471472 while input.peek(Token![,]) {473 input.parse::<Token![,]>()?;474 if input.is_empty() {475 476 break;477 }478 let expr = input.parse()?;479 arguments.push(expr);480 }481482 if !input.is_empty() {483 return Err(syn::Error::new(input.span(), "unexpected trailing input"));484 }485486 Ok(Self {487 formatting,488 arguments,489 })490 }491}492fn is_format_str(i: &str) -> bool {493 let mut is_plain = true;494 495 496 let mut is_bracket = 0i8;497 for ele in i.chars() {498 match ele {499 '{' if is_bracket == -1 => {500 is_bracket = 0;501 }502 '}' if is_bracket == -1 => {503 is_plain = false;504 break;505 }506 '}' if is_bracket == 1 => {507 is_bracket = 0;508 }509 '{' if is_bracket == 1 => {510 is_plain = false;511 break;512 }513 '{' => {514 is_bracket = -1;515 }516 '}' => {517 is_bracket = 1;518 }519 _ if is_bracket != 0 => {520 is_plain = false;521 break;522 }523 _ => {}524 }525 }526 !is_plain || is_bracket != 0527}528impl FormatInput {529 fn expand(self) -> TokenStream {530 let format = self.formatting;531 if is_format_str(&format.value()) {532 let args = self.arguments;533 quote! {534 ::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))535 }536 } else {537 if let Some(first) = self.arguments.first() {538 return syn::Error::new(539 first.span(),540 "string has no formatting codes, it should not have the arguments",541 )542 .into_compile_error();543 }544 quote! {545 ::jrsonnet_evaluator::IStr::from(#format)546 }547 }548 }549}550551552553554555556#[proc_macro]557pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {558 let input = parse_macro_input!(input as FormatInput);559 input.expand().into()560}561562563#[proc_macro]564#[allow(non_snake_case)]565pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {566 let input = parse_macro_input!(input as ExprClosure);567568 let span = input.inputs.span();569 let move_check = input.capture.is_none().then(|| {570 quote_spanned! {span => {571 compile_error!("Thunk! needs to be called with move closure");572 }}573 });574575 let (env, closure, args) = syn_dissect_closure::split_env(input);576577 let trace_check = args.iter().map(|el| {578 let span = el.span();579 quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}580 });581582 quote! {{583 #move_check584 #(#trace_check)*585 ::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))586 }}.into()587}