1use proc_macro2::TokenStream;2use quote::quote;3use syn::{4 parenthesized,5 parse::{Parse, ParseStream},6 parse_macro_input,7 punctuated::Punctuated,8 spanned::Spanned,9 token::{self, Comma},10 Attribute, DeriveInput, Error, FnArg, GenericArgument, Ident, ItemFn, LitStr, Pat, Path,11 PathArguments, Result, ReturnType, Token, Type,12};1314fn parse_attr<A: Parse, I>(attrs: &[Attribute], ident: I) -> Result<Option<A>>15where16 Ident: PartialEq<I>,17{18 let attrs = attrs19 .iter()20 .filter(|a| a.path.is_ident(&ident))21 .collect::<Vec<_>>();22 if attrs.len() > 1 {23 return Err(Error::new(24 attrs[1].span(),25 "this attribute may be specified only once",26 ));27 } else if attrs.is_empty() {28 return Ok(None);29 }30 let attr = attrs[0];31 let attr = attr.parse_args::<A>()?;3233 Ok(Some(attr))34}3536fn path_is(path: &Path, needed: &str) -> bool {37 path.leading_colon.is_none()38 && !path.segments.is_empty()39 && path.segments.iter().last().unwrap().ident == needed40}4142fn type_is_path<'ty>(ty: &'ty Type, needed: &str) -> Option<&'ty PathArguments> {43 match ty {44 Type::Path(path) if path.qself.is_none() && path_is(&path.path, needed) => {45 let args = &path.path.segments.iter().last().unwrap().arguments;46 Some(args)47 }48 _ => None,49 }50}5152fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {53 Ok(if let Some(args) = type_is_path(ty, "Option") {54 55 let generic_arg = match args {56 PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),57 _ => return Err(Error::new(args.span(), "missing option generic")),58 };59 60 match generic_arg {61 GenericArgument::Type(ty) => Some(ty),62 _ => {63 return Err(Error::new(64 generic_arg.span(),65 "option generic should be a type",66 ))67 }68 }69 } else {70 None71 })72}7374struct Field {75 name: Ident,76 _colon: Token![:],77 ty: Type,78}79impl Parse for Field {80 fn parse(input: ParseStream) -> syn::Result<Self> {81 Ok(Self {82 name: input.parse()?,83 _colon: input.parse()?,84 ty: input.parse()?,85 })86 }87}8889mod kw {90 syn::custom_keyword!(fields);91 syn::custom_keyword!(rename);92 syn::custom_keyword!(flatten);93 syn::custom_keyword!(ok);94}9596struct EmptyAttr;97impl Parse for EmptyAttr {98 fn parse(_input: ParseStream) -> Result<Self> {99 Ok(Self)100 }101}102103struct BuiltinAttrs {104 fields: Vec<Field>,105}106impl Parse for BuiltinAttrs {107 fn parse(input: ParseStream) -> syn::Result<Self> {108 if input.is_empty() {109 return Ok(Self { fields: Vec::new() });110 }111 input.parse::<kw::fields>()?;112 let fields;113 parenthesized!(fields in input);114 let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;115 Ok(Self {116 fields: p.into_iter().collect(),117 })118 }119}120121enum ArgInfo {122 Normal {123 ty: Box<Type>,124 is_option: bool,125 name: String,126 cfg_attrs: Vec<Attribute>,127 128 },129 Lazy {130 is_option: bool,131 name: String,132 },133 State,134 Location,135 This,136}137138impl ArgInfo {139 fn parse(name: &str, arg: &FnArg) -> Result<Self> {140 let arg = match arg {141 FnArg::Receiver(_) => unreachable!(),142 FnArg::Typed(a) => a,143 };144 let ident = match &arg.pat as &Pat {145 Pat::Ident(i) => i.ident.clone(),146 _ => return Err(Error::new(arg.pat.span(), "arg should be plain identifier")),147 };148 let ty = &arg.ty;149 if type_is_path(ty, "State").is_some() {150 return Ok(Self::State);151 } else if type_is_path(ty, "CallLocation").is_some() {152 return Ok(Self::Location);153 } else if type_is_path(ty, "LazyVal").is_some() {154 return Ok(Self::Lazy {155 is_option: false,156 name: ident.to_string(),157 });158 }159160 match &ty as &Type {161 Type::Reference(r) if type_is_path(&r.elem, &name).is_some() => return Ok(Self::This),162 _ => {}163 }164165 let (is_option, ty) = if let Some(ty) = extract_type_from_option(ty)? {166 if type_is_path(ty, "LazyVal").is_some() {167 return Ok(Self::Lazy {168 is_option: true,169 name: ident.to_string(),170 });171 }172173 (true, Box::new(ty.clone()))174 } else {175 (false, ty.clone())176 };177178 let cfg_attrs = arg179 .attrs180 .iter()181 .filter(|a| a.path.is_ident("cfg"))182 .cloned()183 .collect();184185 Ok(Self::Normal {186 ty,187 is_option,188 name: ident.to_string(),189 cfg_attrs,190 })191 }192}193194#[proc_macro_attribute]195pub fn builtin(196 attr: proc_macro::TokenStream,197 item: proc_macro::TokenStream,198) -> proc_macro::TokenStream {199 let attr = parse_macro_input!(attr as BuiltinAttrs);200 let item: ItemFn = parse_macro_input!(item);201202 match builtin_inner(attr, item) {203 Ok(v) => v.into(),204 Err(e) => e.into_compile_error().into(),205 }206}207208fn builtin_inner(attr: BuiltinAttrs, fun: ItemFn) -> syn::Result<TokenStream> {209 let result = match fun.sig.output {210 ReturnType::Default => {211 return Err(Error::new(212 fun.sig.span(),213 "builtin should return something",214 ))215 }216 ReturnType::Type(_, ref ty) => ty.clone(),217 };218 let result_inner = if let Some(args) = type_is_path(&result, "Result") {219 let generic_arg = match args {220 PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),221 _ => return Err(Error::new(args.span(), "missing result generic")),222 };223 224 match generic_arg {225 GenericArgument::Type(ty) => ty,226 _ => {227 return Err(Error::new(228 generic_arg.span(),229 "option generic should be a type",230 ))231 }232 }233 } else {234 return Err(Error::new(result.span(), "return value should be result"));235 };236237 let name = fun.sig.ident.to_string();238 let args = fun239 .sig240 .inputs241 .iter()242 .map(|arg| ArgInfo::parse(&name, arg))243 .collect::<Result<Vec<_>>>()?;244245 let params_desc = args.iter().flat_map(|a| match a {246 ArgInfo::Normal {247 is_option,248 name,249 cfg_attrs,250 ..251 } => Some(quote! {252 #(#cfg_attrs)*253 BuiltinParam {254 name: std::borrow::Cow::Borrowed(#name),255 has_default: #is_option,256 },257 }),258 ArgInfo::Lazy { is_option, name } => Some(quote! {259 BuiltinParam {260 name: std::borrow::Cow::Borrowed(#name),261 has_default: #is_option,262 },263 }),264 ArgInfo::State => None,265 ArgInfo::Location => None,266 ArgInfo::This => None,267 });268269 let pass = args.iter().map(|a| match a {270 ArgInfo::Normal {271 ty,272 is_option,273 name,274 cfg_attrs,275 } => {276 let eval = quote! {s.push_description(277 || format!("argument <{}> evaluation", #name),278 || <#ty>::from_untyped(value.evaluate(s.clone())?, s.clone()),279 )?};280 let value = if *is_option {281 quote! {if let Some(value) = parsed.get(#name) {282 Some(#eval)283 } else {284 None285 },}286 } else {287 quote! {{288 let value = parsed.get(#name).expect("args shape is checked");289 #eval290 },}291 };292 quote! {293 #(#cfg_attrs)*294 #value295 }296 }297 ArgInfo::Lazy { is_option, name } => {298 if *is_option {299 quote! {if let Some(value) = parsed.get(#name) {300 Some(value.clone())301 } else {302 None303 }}304 } else {305 quote! {306 parsed.get(#name).expect("args shape is correct").clone(),307 }308 }309 }310 ArgInfo::State => quote! {s.clone(),},311 ArgInfo::Location => quote! {location,},312 ArgInfo::This => quote! {self,},313 });314315 let fields = attr.fields.iter().map(|field| {316 let name = &field.name;317 let ty = &field.ty;318 quote! {319 pub #name: #ty,320 }321 });322323 let name = &fun.sig.ident;324 let vis = &fun.vis;325 let static_ext = if attr.fields.is_empty() {326 quote! {327 impl #name {328 pub const INST: &'static dyn StaticBuiltin = &#name {};329 }330 impl StaticBuiltin for #name {}331 }332 } else {333 quote! {}334 };335 let static_derive_copy = if attr.fields.is_empty() {336 quote! {, Copy}337 } else {338 quote! {}339 };340341 Ok(quote! {342 #fun343 #[doc(hidden)]344 #[allow(non_camel_case_types)]345 #[derive(Clone, gcmodule::Trace #static_derive_copy)]346 #vis struct #name {347 #(#fields)*348 }349 const _: () = {350 use ::jrsonnet_evaluator::{351 State, Val,352 function::{Builtin, CallLocation, StaticBuiltin, BuiltinParam, ArgsLike, parse_builtin_call},353 error::Result, Context, typed::Typed,354 parser::ExprLocation,355 };356 const PARAMS: &'static [BuiltinParam] = &[357 #(#params_desc)*358 ];359360 #static_ext361 impl Builtin for #name362 where363 Self: 'static364 {365 fn name(&self) -> &str {366 stringify!(#name)367 }368 fn params(&self) -> &[BuiltinParam] {369 PARAMS370 }371 fn call(&self, s: State, ctx: Context, location: CallLocation, args: &dyn ArgsLike) -> Result<Val> {372 let parsed = parse_builtin_call(s.clone(), ctx, &PARAMS, args, false)?;373374 let result: #result = #name(#(#pass)*);375 let result = result?;376 <#result_inner>::into_untyped(result, s)377 }378 }379 };380 })381}382383#[derive(Default)]384struct TypedAttr {385 rename: Option<String>,386 flatten: bool,387 388 389 flatten_ok: bool,390}391impl Parse for TypedAttr {392 fn parse(input: ParseStream) -> syn::Result<Self> {393 let mut out = Self::default();394 loop {395 let lookahead = input.lookahead1();396 if lookahead.peek(kw::rename) {397 input.parse::<kw::rename>()?;398 input.parse::<Token![=]>()?;399 let name = input.parse::<LitStr>()?;400 if out.rename.is_some() {401 return Err(Error::new(402 name.span(),403 "rename attribute may only be specified once",404 ));405 }406 out.rename = Some(name.value());407 } else if lookahead.peek(kw::flatten) {408 input.parse::<kw::flatten>()?;409 out.flatten = true;410 if input.peek(token::Paren) {411 let content;412 parenthesized!(content in input);413 let lookahead = content.lookahead1();414 if lookahead.peek(kw::ok) {415 content.parse::<kw::ok>()?;416 out.flatten_ok = true;417 } else {418 return Err(lookahead.error());419 }420 }421 } else if input.is_empty() {422 break;423 } else {424 return Err(lookahead.error());425 }426 if input.peek(Token![,]) {427 input.parse::<Token![,]>()?;428 } else {429 break;430 }431 }432 433 434 435 Ok(out)436 }437}438439struct TypedField {440 attr: TypedAttr,441 ident: Ident,442 ty: Type,443 is_option: bool,444}445impl TypedField {446 fn parse(field: &syn::Field) -> Result<Self> {447 let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();448 let ident = if let Some(ident) = field.ident.clone() {449 ident450 } else {451 return Err(Error::new(452 field.span(),453 "this field should appear in output object, but it has no visible name",454 ));455 };456 let (is_option, ty) = if let Some(ty) = extract_type_from_option(&field.ty)? {457 (true, ty.clone())458 } else {459 (false, field.ty.clone())460 };461 if is_option && attr.flatten {462 if !attr.flatten_ok {463 return Err(Error::new(464 field.span(),465 "strategy should be set when flattening Option",466 ));467 }468 } else {469 if attr.flatten_ok {470 return Err(Error::new(471 field.span(),472 "flatten(ok) is only useable on optional fields",473 ));474 }475 }476 Ok(Self {477 attr,478 ident,479 ty,480 is_option,481 })482 }483 484 fn name(&self) -> Option<String> {485 if self.attr.flatten {486 return None;487 }488 Some(489 self.attr490 .rename491 .clone()492 .unwrap_or_else(|| self.ident.to_string()),493 )494 }495496 fn expand_field(&self) -> Option<TokenStream> {497 if self.is_option {498 return None;499 }500 let name = self.name()?;501 let ty = &self.ty;502 Some(quote! {503 (#name, <#ty>::TYPE)504 })505 }506 fn expand_parse(&self) -> TokenStream {507 let ident = &self.ident;508 let ty = &self.ty;509 if self.attr.flatten {510 511 return if self.is_option {512 quote! {513 #ident: <#ty>::parse(&obj, s.clone()).ok(),514 }515 } else {516 quote! {517 #ident: <#ty>::parse(&obj, s.clone())?,518 }519 };520 };521522 let name = self.name().unwrap();523 let value = if self.is_option {524 quote! {525 if let Some(value) = obj.get(s.clone(), #name.into())? {526 Some(<#ty>::from_untyped(value, s.clone())?)527 } else {528 None529 }530 }531 } else {532 quote! {533 <#ty>::from_untyped(obj.get(s.clone(), #name.into())?.ok_or_else(|| Error::NoSuchField(#name.into()))?, s.clone())?534 }535 };536537 quote! {538 #ident: #value,539 }540 }541 fn expand_serialize(&self) -> Result<TokenStream> {542 let ident = &self.ident;543 let ty = &self.ty;544 Ok(if let Some(name) = self.name() {545 if self.is_option {546 quote! {547 if let Some(value) = self.#ident {548 out.member(#name.into()).value(s.clone(), <#ty>::into_untyped(value, s.clone())?)?;549 }550 }551 } else {552 quote! {553 out.member(#name.into()).value(s.clone(), <#ty>::into_untyped(self.#ident, s.clone())?)?;554 }555 }556 } else if self.is_option {557 quote! {558 if let Some(value) = self.#ident {559 value.serialize(s.clone(), out)?;560 }561 }562 } else {563 quote! {564 self.#ident.serialize(s.clone(), out)?;565 }566 })567 }568}569570#[proc_macro_derive(Typed, attributes(typed))]571pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {572 let input = parse_macro_input!(item as DeriveInput);573574 match derive_typed_inner(input) {575 Ok(v) => v.into(),576 Err(e) => e.to_compile_error().into(),577 }578}579580fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {581 let data = match &input.data {582 syn::Data::Struct(s) => s,583 _ => return Err(Error::new(input.span(), "only structs supported")),584 };585586 let ident = &input.ident;587 let fields = data588 .fields589 .iter()590 .map(TypedField::parse)591 .collect::<Result<Vec<_>>>()?;592593 let typed = {594 let fields = fields595 .iter()596 .flat_map(TypedField::expand_field)597 .collect::<Vec<_>>();598 let len = fields.len();599 quote! {600 const ITEMS: [(&'static str, &'static ComplexValType); #len] = [601 #(#fields,)*602 ];603 impl Typed for #ident {604 const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&ITEMS);605606 fn from_untyped(value: Val, s: State) -> Result<Self> {607 let obj = value.as_obj().expect("shape is correct");608 Self::parse(&obj, s)609 }610611 fn into_untyped(value: Self, s: State) -> Result<Val> {612 let mut out = ObjValueBuilder::new();613 value.serialize(s, &mut out)?;614 Ok(Val::Obj(out.build()))615 }616617 }618 }619 };620621 let fields_parse = fields.iter().map(TypedField::expand_parse);622 let fields_serialize = fields623 .iter()624 .map(TypedField::expand_serialize)625 .collect::<Result<Vec<_>>>()?;626627 Ok(quote! {628 const _: () = {629 use ::jrsonnet_evaluator::{630 typed::{ComplexValType, Typed, TypedObj, CheckType},631 Val, State,632 error::{LocError, Error, Result},633 ObjValueBuilder, ObjValue,634 };635636 #typed637638 impl TypedObj for #ident {639 fn serialize(self, s: State, out: &mut ObjValueBuilder) -> Result<(), LocError> {640 #(#fields_serialize)*641642 Ok(())643 }644 fn parse(obj: &ObjValue, s: State) -> Result<Self, LocError> {645 Ok(Self {646 #(#fields_parse)*647 })648 }649 }650 };651 })652}