difftreelog
perf use prepared call for KeyF
in: master
9 files changed
crates/jrsonnet-evaluator/src/function/builtin.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -3,8 +3,8 @@
use jrsonnet_gcmodule::{cc_dyn, Trace, TraceBox};
use jrsonnet_parser::function::{FunctionSignature, ParamDefault, ParamName, ParamParse};
-use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};
-use crate::{Context, Result, Val};
+use super::CallLocation;
+use crate::{Result, Thunk, Val};
#[macro_export]
macro_rules! params {
@@ -34,8 +34,8 @@
self.0.params()
}
- fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {
- self.0.call(ctx, loc, args)
+ fn call(&self, loc: CallLocation<'_>, args: &[Option<Thunk<Val>>]) -> Result<Val> {
+ self.0.call(loc, args)
}
fn as_any(&self) -> &dyn Any {
@@ -52,7 +52,7 @@
/// Parameter names for named calls
fn params(&self) -> FunctionSignature;
/// Call the builtin
- fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val>;
+ fn call(&self, loc: CallLocation<'_>, args: &[Option<Thunk<Val>>]) -> Result<Val>;
fn as_any(&self) -> &dyn Any;
}
@@ -96,11 +96,10 @@
self.params.clone()
}
- fn call(&self, ctx: Context, _loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {
- let args = parse_builtin_call(ctx, self.params.clone(), args, true)?;
+ fn call(&self, _loc: CallLocation<'_>, args: &[Option<Thunk<Val>>]) -> Result<Val> {
let args = args
.into_iter()
- .map(|a| a.expect("legacy natives have no default params"))
+ .map(|a| a.as_ref().expect("legacy natives have no default params"))
.map(|a| a.evaluate())
.collect::<Result<Vec<Val>>>()?;
self.handler.call(&args)
crates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -11,7 +11,8 @@
arglike::OptionalContext,
builtin::{Builtin, StaticBuiltin},
native::NativeDesc,
- parse::{parse_default_function_call, parse_function_call},
+ parse::{parse_builtin_call, parse_default_function_call, parse_function_call},
+ prepared::{parse_prepared_builtin_call, parse_prepared_function_call, PreparedCall},
};
use crate::{
bail, error::ErrorKind::*, evaluate, evaluate_trivial, function::builtin::BuiltinFunc, Context,
@@ -22,7 +23,9 @@
pub mod builtin;
pub mod native;
pub mod parse;
-pub mod prepared;
+mod prepared;
+
+pub use prepared::PreparedFuncVal;
pub use jrsonnet_parser::function::*;
@@ -173,7 +176,6 @@
tailstrict: bool,
) -> Result<Val> {
match self {
- Self::Id => ID.call(call_ctx, loc, args),
Self::Normal(func) => {
let body_ctx = func.call_body_context(call_ctx, args, tailstrict)?;
evaluate(body_ctx, &func.body)
@@ -184,8 +186,18 @@
}
thunk.evaluate()
}
- Self::StaticBuiltin(b) => b.call(call_ctx, loc, args),
- Self::Builtin(b) => b.call(call_ctx, loc, args),
+ Self::Id => {
+ let args = parse_builtin_call(call_ctx, ID.params(), args, tailstrict)?;
+ ID.call(loc, &args)
+ }
+ Self::StaticBuiltin(b) => {
+ let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;
+ b.call(loc, &args)
+ }
+ Self::Builtin(b) => {
+ let args = parse_builtin_call(call_ctx, b.params(), args, tailstrict)?;
+ b.call(loc, &args)
+ }
}
}
pub fn evaluate_simple<A: ArgsLike + OptionalContext>(
@@ -200,6 +212,41 @@
tailstrict,
)
}
+
+ pub(crate) fn evaluate_prepared(
+ &self,
+ prepared: &PreparedCall,
+ loc: CallLocation<'_>,
+ unnamed: &[Thunk<Val>],
+ named: &[Thunk<Val>],
+ _tailstrict: bool,
+ ) -> Result<Val> {
+ match self {
+ FuncVal::Id => {
+ let args = parse_prepared_builtin_call(prepared, ID.params(), unnamed, named)?;
+ ID.call(loc, &args)
+ }
+ FuncVal::Normal(func) => {
+ let body_ctx = parse_prepared_function_call(
+ func.ctx.clone(),
+ prepared,
+ &func.params,
+ unnamed,
+ named,
+ )?;
+ evaluate(body_ctx, &func.body)
+ }
+ FuncVal::Thunk(t) => t.evaluate(),
+ FuncVal::StaticBuiltin(b) => {
+ let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named)?;
+ b.call(loc, &args)
+ }
+ FuncVal::Builtin(b) => {
+ let args = parse_prepared_builtin_call(prepared, b.params(), unnamed, named)?;
+ b.call(loc, &args)
+ }
+ }
+ }
/// Convert jsonnet function to plain `Fn` value.
pub fn into_native<D: NativeDesc>(self) -> D::Value {
D::into_native(self)
crates/jrsonnet-evaluator/src/function/prepared.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/prepared.rs
+++ b/crates/jrsonnet-evaluator/src/function/prepared.rs
@@ -1,3 +1,6 @@
+use std::rc::Rc;
+
+use jrsonnet_gcmodule::{Acyclic, Trace};
use jrsonnet_parser::function::FunctionSignature;
use jrsonnet_parser::{ExprParams, IStr};
use rustc_hash::{FxHashMap, FxHashSet};
@@ -7,6 +10,34 @@
use crate::{bail, error::ErrorKind::*, Result};
use crate::{evaluate_named_param, Context, ContextBuilder, Pending, Thunk, Val};
+use super::{CallLocation, FuncVal};
+
+#[derive(Debug, Trace, Clone)]
+pub struct PreparedFuncVal {
+ fun: FuncVal,
+ prepared: Rc<PreparedCall>,
+}
+
+impl PreparedFuncVal {
+ pub fn new(fun: FuncVal, unnamed: usize, named: &[IStr]) -> Result<Self> {
+ let prepared = prepare_call(fun.params(), unnamed, named)?;
+ Ok(Self {
+ fun,
+ prepared: Rc::new(prepared),
+ })
+ }
+ pub fn call(
+ &self,
+ loc: CallLocation<'_>,
+ unnamed: &[Thunk<Val>],
+ named: &[Thunk<Val>],
+ ) -> Result<Val> {
+ self.fun
+ .evaluate_prepared(&self.prepared, loc, unnamed, named, false)
+ }
+}
+
+#[derive(Acyclic, Debug)]
pub struct PreparedCall {
// Param, named input.
named: Vec<(usize, usize)>,
crates/jrsonnet-macros/src/lib.rsdiffbeforeafterboth1use std::string::String;23use proc_macro2::TokenStream;4use quote::{quote, quote_spanned};5use syn::{6 Attribute, DeriveInput, Error, Expr, ExprClosure, FnArg, GenericArgument, Ident, ItemFn, LitStr, Meta, Pat, Path, PathArguments, Result, ReturnType, Token, Type, parenthesized, parse::{Parse, ParseStream}, parse_macro_input, punctuated::Punctuated, spanned::Spanned, token::{self, Comma}7};89fn try_parse_attr_noargs<I>(attrs: &[Attribute], ident: I) -> Result<bool>10where11 Ident: PartialEq<I>,12{13 let attrs = attrs14 .iter()15 .filter(|a| a.path().is_ident(&ident))16 .collect::<Vec<_>>();17 if attrs.len() > 1 {18 return Err(Error::new(19 attrs[1].span(),20 "this attribute may be specified only once",21 ));22 } else if attrs.is_empty() {23 return Ok(false);24 }25 let attr = attrs[0];2627 match attr.meta {28 Meta::Path(_) => Ok(true),29 _ => Ok(false),30 }31}32fn parse_attr<A: Parse, I>(attrs: &[Attribute], ident: I) -> Result<Option<A>>33where34 Ident: PartialEq<I>,35{36 let attrs = attrs37 .iter()38 .filter(|a| a.path().is_ident(&ident))39 .collect::<Vec<_>>();40 if attrs.len() > 1 {41 return Err(Error::new(42 attrs[1].span(),43 "this attribute may be specified only once",44 ));45 } else if attrs.is_empty() {46 return Ok(None);47 }48 let attr = attrs[0];49 let attr = attr.parse_args::<A>()?;5051 Ok(Some(attr))52}53fn remove_attr<I>(attrs: &mut Vec<Attribute>, ident: I)54where55 Ident: PartialEq<I>,56{57 attrs.retain(|a| !a.path().is_ident(&ident));58}5960fn path_is(path: &Path, needed: &str) -> bool {61 path.leading_colon.is_none()62 && !path.segments.is_empty()63 && path.segments.iter().last().unwrap().ident == needed64}6566fn type_is_path<'ty>(ty: &'ty Type, needed: &str) -> Option<&'ty PathArguments> {67 match ty {68 Type::Path(path) if path.qself.is_none() && path_is(&path.path, needed) => {69 let args = &path.path.segments.iter().last().unwrap().arguments;70 Some(args)71 }72 _ => None,73 }74}7576fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {77 let Some(args) = type_is_path(ty, "Option") else {78 return Ok(None);79 };80 // It should have only on angle-bracketed param ("<String>"):81 let PathArguments::AngleBracketed(params) = args else {82 return Err(Error::new(args.span(), "missing option generic"));83 };84 let generic_arg = params.args.iter().next().unwrap();85 // This argument must be a type:86 let GenericArgument::Type(ty) = generic_arg else {87 return Err(Error::new(88 generic_arg.span(),89 "option generic should be a type",90 ));91 };92 Ok(Some(ty))93}9495struct Field {96 attrs: Vec<Attribute>,97 name: Ident,98 _colon: Token![:],99 ty: Type,100}101impl Parse for Field {102 fn parse(input: ParseStream) -> syn::Result<Self> {103 Ok(Self {104 attrs: input.call(Attribute::parse_outer)?,105 name: input.parse()?,106 _colon: input.parse()?,107 ty: input.parse()?,108 })109 }110}111112mod kw {113 syn::custom_keyword!(fields);114 syn::custom_keyword!(rename);115 syn::custom_keyword!(alias);116 syn::custom_keyword!(flatten);117 syn::custom_keyword!(add);118 syn::custom_keyword!(hide);119 syn::custom_keyword!(ok);120}121122struct BuiltinAttrs {123 fields: Vec<Field>,124}125impl Parse for BuiltinAttrs {126 fn parse(input: ParseStream) -> syn::Result<Self> {127 if input.is_empty() {128 return Ok(Self { fields: Vec::new() });129 }130 input.parse::<kw::fields>()?;131 let fields;132 parenthesized!(fields in input);133 let p = Punctuated::<Field, Comma>::parse_terminated(&fields)?;134 Ok(Self {135 fields: p.into_iter().collect(),136 })137 }138}139140enum Optionality {141 Required,142 Optional,143 Default(Expr),144 TypeDefault,145}146147#[allow(148 clippy::large_enum_variant,149 reason = "this macro is not that hot for it to matter"150)]151enum ArgInfo {152 Normal {153 ty: Box<Type>,154 optionality: Optionality,155 name: Option<String>,156 cfg_attrs: Vec<Attribute>,157 },158 Lazy {159 is_option: bool,160 name: Option<String>,161 },162 Context,163 Location,164 This,165}166167impl ArgInfo {168 fn parse(name: &str, arg: &mut FnArg) -> Result<Self> {169 let FnArg::Typed(arg) = arg else {170 unreachable!()171 };172 let ident = match &arg.pat as &Pat {173 Pat::Ident(i) => Some(i.ident.clone()),174 _ => None,175 };176 let ty = &arg.ty;177 if type_is_path(ty, "Context").is_some() {178 return Ok(Self::Context);179 } else if type_is_path(ty, "CallLocation").is_some() {180 return Ok(Self::Location);181 } else if type_is_path(ty, "Thunk").is_some() {182 return Ok(Self::Lazy {183 is_option: false,184 name: ident.map(|v| v.to_string()),185 });186 }187188 match ty as &Type {189 Type::Reference(r) if type_is_path(&r.elem, name).is_some() => return Ok(Self::This),190 _ => {}191 }192193 let (optionality, ty) = if try_parse_attr_noargs(&mut arg.attrs, "default")? {194 remove_attr(&mut arg.attrs, "default");195 (Optionality::TypeDefault, ty.clone())196 } else if let Some(default) = parse_attr::<_, _>(&arg.attrs, "default")? {197 remove_attr(&mut arg.attrs, "default");198 (Optionality::Default(default), ty.clone())199 } else if let Some(ty) = extract_type_from_option(ty)? {200 if type_is_path(ty, "Thunk").is_some() {201 return Ok(Self::Lazy {202 is_option: true,203 name: ident.map(|v| v.to_string()),204 });205 }206207 (Optionality::Optional, Box::new(ty.clone()))208 } else {209 (Optionality::Required, ty.clone())210 };211212 let cfg_attrs = arg213 .attrs214 .iter()215 .filter(|a| a.path().is_ident("cfg"))216 .cloned()217 .collect();218219 Ok(Self::Normal {220 ty,221 optionality,222 name: ident.map(|v| v.to_string()),223 cfg_attrs,224 })225 }226}227228#[proc_macro_attribute]229pub fn builtin(230 attr: proc_macro::TokenStream,231 item: proc_macro::TokenStream,232) -> proc_macro::TokenStream {233 let attr = parse_macro_input!(attr as BuiltinAttrs);234 let item_fn = parse_macro_input!(item as ItemFn);235236 match builtin_inner(attr, item_fn) {237 Ok(v) => v.into(),238 Err(e) => e.into_compile_error().into(),239 }240}241242#[allow(clippy::too_many_lines)]243fn builtin_inner(attr: BuiltinAttrs, mut fun: ItemFn) -> syn::Result<TokenStream> {244 let ReturnType::Type(_, result) = &fun.sig.output else {245 return Err(Error::new(246 fun.sig.span(),247 "builtin should return something",248 ));249 };250251 let name = fun.sig.ident.to_string();252 let args = fun253 .sig254 .inputs255 .iter_mut()256 .map(|arg| ArgInfo::parse(&name, arg))257 .collect::<Result<Vec<_>>>()?;258259 let params_desc = args.iter().filter_map(|a| match a {260 ArgInfo::Normal {261 optionality,262 name,263 cfg_attrs,264 ..265 } => {266 let name = name267 .as_ref()268 .map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});269 let default = match optionality {270 Optionality::Required => quote!(ParamDefault::None),271 Optionality::Optional | Optionality::TypeDefault => quote!(ParamDefault::Exists),272 Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),273 };274 Some(quote! {275 #(#cfg_attrs)*276 [#name => #default],277 })278 }279 ArgInfo::Lazy { is_option, name } => {280 let name = name281 .as_ref()282 .map_or_else(|| quote! {unnamed}, |n| quote! {named(#n)});283 Some(quote! {284 [#name => ParamDefault::exists(#is_option)],285 })286 }287 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,288 });289290 let mut id = 0usize;291 let pass = args292 .iter()293 .map(|a| match a {294 ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {295 let cid = id;296 id += 1;297 (quote! {#cid}, a)298 }299 ArgInfo::Context | ArgInfo::Location | ArgInfo::This => {300 (quote! {compile_error!("should not use id")}, a)301 }302 })303 .map(|(id, a)| match a {304 ArgInfo::Normal {305 ty,306 optionality,307 name,308 cfg_attrs,309 } => {310 let name = name.as_ref().map_or("<unnamed>", String::as_str);311 let eval = quote! {jrsonnet_evaluator::in_description_frame(312 || format!("argument <{}> evaluation", #name),313 || <#ty>::from_untyped(value.evaluate()?),314 )?};315 let value = match optionality {316 Optionality::Required => quote! {{317 let value = parsed[#id].as_ref().expect("args shape is checked");318 #eval319 },},320 Optionality::Optional => quote! {if let Some(value) = &parsed[#id] {321 Some(#eval)322 } else {323 None324 },},325 Optionality::Default(expr) => quote! {if let Some(value) = &parsed[#id] {326 #eval327 } else {328 let v: #ty = #expr;329 v330 },},331 Optionality::TypeDefault => quote! {if let Some(value) = &parsed[#id] {332 #eval333 } else {334 let v: #ty = Default::default();335 v336 },},337 };338 quote! {339 #(#cfg_attrs)*340 #value341 }342 }343 ArgInfo::Lazy { is_option, .. } => {344 if *is_option {345 quote! {if let Some(value) = &parsed[#id] {346 Some(value.clone())347 } else {348 None349 },}350 } else {351 quote! {352 parsed[#id].as_ref().expect("args shape is correct").clone(),353 }354 }355 }356 ArgInfo::Context => quote! {ctx.clone(),},357 ArgInfo::Location => quote! {location,},358 ArgInfo::This => quote! {self,},359 });360361 let fields = attr.fields.iter().map(|field| {362 let attrs = &field.attrs;363 let name = &field.name;364 let ty = &field.ty;365 quote! {366 #(#attrs)*367 pub #name: #ty,368 }369 });370371 let name = &fun.sig.ident;372 let vis = &fun.vis;373 let static_ext = if attr.fields.is_empty() {374 quote! {375 impl #name {376 pub const INST: &'static dyn StaticBuiltin = &#name {};377 }378 impl StaticBuiltin for #name {}379 }380 } else {381 quote! {}382 };383 let static_derive_copy = if attr.fields.is_empty() {384 quote! {, Copy}385 } else {386 quote! {}387 };388389 Ok(quote! {390 #fun391392 #[doc(hidden)]393 #[allow(non_camel_case_types)]394 #[derive(Clone, jrsonnet_gcmodule::Trace #static_derive_copy)]395 #vis struct #name {396 #(#fields)*397 }398 const _: () = {399 use ::jrsonnet_evaluator::{400 State, Val,401 function::{builtin::{Builtin, StaticBuiltin}, FunctionSignature, ParamParse, ParamName, ParamDefault, CallLocation, ArgsLike, parse::parse_builtin_call},402 Result, Context, typed::Typed,403 parser::Span, params, Thunk,404 };405 params!(406 #(#params_desc)*407 );408409 #static_ext410 impl Builtin for #name411 where412 Self: 'static413 {414 fn name(&self) -> &str {415 stringify!(#name)416 }417 fn params(&self) -> FunctionSignature {418 PARAMS.with(|p| p.clone())419 }420 #[allow(unused_variables)]421 fn call(&self, location: CallLocation<'_>, parsed: &[Option<Thunk<Val>>]) -> Result<Val> {422 let result: #result = #name(#(#pass)*);423 <_ as Typed>::into_result(result)424 }425 fn as_any(&self) -> &dyn ::std::any::Any {426 self427 }428 }429 };430 })431}432433#[derive(Default)]434#[allow(clippy::struct_excessive_bools)]435struct TypedAttr {436 rename: Option<String>,437 aliases: Vec<String>,438 flatten: bool,439 /// flatten(ok) strategy for flattened optionals440 /// field would be None in case of any parsing error (as in serde)441 flatten_ok: bool,442 // Should it be `field+:` instead of `field:`443 add: bool,444 // Should it be `field::` instead of `field:`445 hide: bool,446}447impl Parse for TypedAttr {448 fn parse(input: ParseStream) -> syn::Result<Self> {449 let mut out = Self::default();450 loop {451 let lookahead = input.lookahead1();452 if lookahead.peek(kw::rename) {453 input.parse::<kw::rename>()?;454 input.parse::<Token![=]>()?;455 let name = input.parse::<LitStr>()?;456 if out.rename.is_some() {457 return Err(Error::new(458 name.span(),459 "rename attribute may only be specified once",460 ));461 }462 out.rename = Some(name.value());463 } else if lookahead.peek(kw::alias) {464 input.parse::<kw::alias>()?;465 input.parse::<Token![=]>()?;466 let alias = input.parse::<LitStr>()?;467 out.aliases.push(alias.value());468 } else if lookahead.peek(kw::flatten) {469 input.parse::<kw::flatten>()?;470 out.flatten = true;471 if input.peek(token::Paren) {472 let content;473 parenthesized!(content in input);474 let lookahead = content.lookahead1();475 if lookahead.peek(kw::ok) {476 content.parse::<kw::ok>()?;477 out.flatten_ok = true;478 } else {479 return Err(lookahead.error());480 }481 }482 } else if lookahead.peek(kw::add) {483 input.parse::<kw::add>()?;484 out.add = true;485 } else if lookahead.peek(kw::hide) {486 input.parse::<kw::hide>()?;487 out.hide = true;488 } else if input.is_empty() {489 break;490 } else {491 return Err(lookahead.error());492 }493 if input.peek(Token![,]) {494 input.parse::<Token![,]>()?;495 } else {496 break;497 }498 }499 Ok(out)500 }501}502503struct TypedField {504 attr: TypedAttr,505 ident: Ident,506 ty: Type,507 is_option: bool,508 is_lazy: bool,509}510impl TypedField {511 fn parse(field: &syn::Field) -> Result<Self> {512 let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();513 let Some(ident) = field.ident.clone() else {514 return Err(Error::new(515 field.span(),516 "this field should appear in output object, but it has no visible name",517 ));518 };519 let (is_option, ty) = extract_type_from_option(&field.ty)?520 .map_or_else(|| (false, field.ty.clone()), |ty| (true, ty.clone()));521 if is_option && attr.flatten {522 if !attr.flatten_ok {523 return Err(Error::new(524 field.span(),525 "strategy should be set when flattening Option",526 ));527 }528 } else if attr.flatten_ok {529 return Err(Error::new(530 field.span(),531 "flatten(ok) is only useable on optional fields",532 ));533 }534535 let is_lazy = type_is_path(&ty, "Thunk").is_some();536537 Ok(Self {538 attr,539 ident,540 ty,541 is_option,542 is_lazy,543 })544 }545 /// None if this field is flattened in jsonnet output546 fn name(&self) -> Option<String> {547 if self.attr.flatten {548 return None;549 }550 Some(551 self.attr552 .rename553 .clone()554 .unwrap_or_else(|| self.ident.to_string()),555 )556 }557558 fn expand_field(&self) -> Option<TokenStream> {559 if self.is_option {560 return None;561 }562 let name = self.name()?;563 let ty = &self.ty;564 Some(quote! {565 (#name, <#ty as Typed>::TYPE)566 })567 }568569 fn expand_parse(&self) -> TokenStream {570 if self.is_option {571 self.expand_parse_optional()572 } else {573 self.expand_parse_mandatory()574 }575 }576577 fn expand_parse_optional(&self) -> TokenStream {578 let ident = &self.ident;579 let ty = &self.ty;580581 // optional flatten is handled in same way as serde582 if self.attr.flatten {583 return quote! {584 #ident: <#ty as TypedObj>::parse(&obj).ok(),585 };586 }587588 let name = self.name().unwrap();589 let aliases = &self.attr.aliases;590591 quote! {592 #ident: {593 let __value = if let Some(__v) = obj.get(#name.into())? {594 Some(__v)595 } #(else if let Some(__v) = obj.get(#aliases.into())? {596 Some(__v)597 })* else {598 None599 };600601 __value.map(<#ty as Typed>::from_untyped).transpose()?602 },603 }604 }605606 fn expand_parse_mandatory(&self) -> TokenStream {607 let ident = &self.ident;608 let ty = &self.ty;609610 // optional flatten is handled in same way as serde611 if self.attr.flatten {612 return quote! {613 #ident: <#ty as TypedObj>::parse(&obj)?,614 };615 }616617 let name = self.name().unwrap();618 let aliases = &self.attr.aliases;619620 let error_text = if aliases.is_empty() {621 // clippy does not understand name variable usage in quote! macro622 #[allow(clippy::redundant_clone)]623 name.clone()624 } else {625 format!("{name} (alias {})", aliases.join(", "))626 };627628 quote! {629 #ident: {630 let __value = if let Some(__v) = obj.get(#name.into())? {631 __v632 } #(else if let Some(__v) = obj.get(#aliases.into())? {633 __v634 })* else {635 return Err(ErrorKind::NoSuchField(#error_text.into(), vec![]).into());636 };637638 <#ty as Typed>::from_untyped(__value)?639 },640 }641 }642643 fn expand_serialize(&self) -> TokenStream {644 let ident = &self.ident;645 let ty = &self.ty;646 self.name().map_or_else(647 || {648 if self.is_option {649 quote! {650 if let Some(value) = self.#ident {651 <#ty as TypedObj>::serialize(value, out)?;652 }653 }654 } else {655 quote! {656 <#ty as TypedObj>::serialize(self.#ident, out)?;657 }658 }659 },660 |name| {661 let hide = if self.attr.hide {662 quote! {.hide()}663 } else {664 quote! {}665 };666 let add = if self.attr.add {667 quote! {.add()}668 } else {669 quote! {}670 };671 let value = if self.is_lazy {672 quote! {673 out.field(#name)674 #hide675 #add676 .try_thunk(<#ty as Typed>::into_lazy_untyped(value))?;677 }678 } else {679 quote! {680 out.field(#name)681 #hide682 #add683 .try_value(<#ty as Typed>::into_untyped(value)?)?;684 }685 };686 if self.is_option {687 quote! {688 if let Some(value) = self.#ident {689 #value690 }691 }692 } else {693 quote! {694 {695 let value = self.#ident;696 #value697 }698 }699 }700 },701 )702 }703}704705#[proc_macro_derive(Typed, attributes(typed))]706pub fn derive_typed(item: proc_macro::TokenStream) -> proc_macro::TokenStream {707 let input = parse_macro_input!(item as DeriveInput);708709 match derive_typed_inner(input) {710 Ok(v) => v.into(),711 Err(e) => e.to_compile_error().into(),712 }713}714715fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {716 let syn::Data::Struct(data) = &input.data else {717 return Err(Error::new(input.span(), "only structs supported"));718 };719720 let ident = &input.ident;721 let fields = data722 .fields723 .iter()724 .map(TypedField::parse)725 .collect::<Result<Vec<_>>>()?;726727 let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();728729 let typed = {730 let fields = fields731 .iter()732 .filter_map(TypedField::expand_field)733 .collect::<Vec<_>>();734 quote! {735 impl #impl_generics Typed for #ident #ty_generics #where_clause {736 const TYPE: &'static ComplexValType = &ComplexValType::ObjectRef(&[737 #(#fields,)*738 ]);739740 fn from_untyped(value: Val) -> JrResult<Self> {741 let obj = value.as_obj().expect("shape is correct");742 Self::parse(&obj)743 }744745 fn into_untyped(value: Self) -> JrResult<Val> {746 let mut out = ObjValueBuilder::new();747 value.serialize(&mut out)?;748 Ok(Val::Obj(out.build()))749 }750751 }752 }753 };754755 let fields_parse = fields.iter().map(TypedField::expand_parse);756 let fields_serialize = fields757 .iter()758 .map(TypedField::expand_serialize)759 .collect::<Vec<_>>();760761 Ok(quote! {762 const _: () = {763 use ::jrsonnet_evaluator::{764 typed::{ComplexValType, Typed, TypedObj, CheckType},765 Val, State,766 error::{ErrorKind, Result as JrResult},767 ObjValueBuilder, ObjValue,768 };769770 #typed771772 impl #impl_generics TypedObj for #ident #ty_generics #where_clause {773 fn serialize(self, out: &mut ObjValueBuilder) -> JrResult<()> {774 #(#fields_serialize)*775776 Ok(())777 }778 fn parse(obj: &ObjValue) -> JrResult<Self> {779 Ok(Self {780 #(#fields_parse)*781 })782 }783 }784 };785 })786}787788struct FormatInput {789 formatting: LitStr,790 arguments: Vec<Expr>,791}792impl Parse for FormatInput {793 fn parse(input: ParseStream) -> Result<Self> {794 let formatting = input.parse()?;795 let mut arguments = Vec::new();796797 while input.peek(Token![,]) {798 input.parse::<Token![,]>()?;799 if input.is_empty() {800 // Trailing comma801 break;802 }803 let expr = input.parse()?;804 arguments.push(expr);805 }806807 if !input.is_empty() {808 return Err(syn::Error::new(input.span(), "unexpected trailing input"));809 }810811 Ok(Self {812 formatting,813 arguments,814 })815 }816}817fn is_format_str(i: &str) -> bool {818 let mut is_plain = true;819 // -1 = {820 // +1 = }821 let mut is_bracket = 0i8;822 for ele in i.chars() {823 match ele {824 '{' if is_bracket == -1 => {825 is_bracket = 0;826 }827 '}' if is_bracket == -1 => {828 is_plain = false;829 break;830 }831 '}' if is_bracket == 1 => {832 is_bracket = 0;833 }834 '{' if is_bracket == 1 => {835 is_plain = false;836 break;837 }838 '{' => {839 is_bracket = -1;840 }841 '}' => {842 is_bracket = 1;843 }844 _ if is_bracket != 0 => {845 is_plain = false;846 break;847 }848 _ => {}849 }850 }851 !is_plain || is_bracket != 0852}853impl FormatInput {854 fn expand(self) -> TokenStream {855 let format = self.formatting;856 if is_format_str(&format.value()) {857 let args = self.arguments;858 quote! {859 ::jrsonnet_evaluator::IStr::from(format!(#format #(, #args)*))860 }861 } else {862 if let Some(first) = self.arguments.first() {863 return syn::Error::new(864 first.span(),865 "string has no formatting codes, it should not have the arguments",866 )867 .into_compile_error();868 }869 quote! {870 ::jrsonnet_evaluator::IStr::from(#format)871 }872 }873 }874}875876/// `IStr` formatting helper877///878/// Using `format!("literal with no codes").into()` is slower than just `"literal with no codes".into()`879/// This macro looks for formatting codes in the input string, and uses880/// `format!()` only when necessary881#[proc_macro]882pub fn format_istr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {883 let input = parse_macro_input!(input as FormatInput);884 input.expand().into()885}886887/// Create Thunk using closure syntax888#[proc_macro]889#[allow(non_snake_case)]890pub fn Thunk(input: proc_macro::TokenStream) -> proc_macro::TokenStream {891 let input = parse_macro_input!(input as ExprClosure);892893 let span = input.inputs.span();894 let move_check = input.capture.is_none().then(|| {895 quote_spanned! {span => {896 compile_error!("Thunk! needs to be called with move closure");897 }}898 });899900 let (env, closure, args) = syn_dissect_closure::split_env(input);901902 let trace_check = args.iter().map(|el| {903 let span = el.span();904 quote_spanned! {span => ::jrsonnet_evaluator::gc::assert_trace(&#el);}905 });906907 quote! {{908 #move_check909 #(#trace_check)*910 ::jrsonnet_evaluator::Thunk::new(::jrsonnet_evaluator::val::MemoizedClosureThunk::new(#env, #closure))911 }}.into()912}crates/jrsonnet-stdlib/src/keyf.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/keyf.rs
@@ -0,0 +1,41 @@
+use jrsonnet_evaluator::function::{CallLocation, FuncVal, PreparedFuncVal};
+use jrsonnet_evaluator::typed::{ComplexValType, Typed, ValType};
+use jrsonnet_evaluator::{Error, Result, Thunk, Val};
+
+#[derive(Default, Clone)]
+pub enum KeyF {
+ #[default]
+ Identity,
+ Prepared(PreparedFuncVal),
+ PrepareFailure(Error),
+}
+impl KeyF {
+ pub fn is_identity(&self) -> bool {
+ matches!(self, Self::Identity)
+ }
+ fn new(val: FuncVal) -> Self {
+ if val.is_identity() {
+ Self::Identity
+ } else {
+ PreparedFuncVal::new(val, 1, &[]).map_or_else(Self::PrepareFailure, Self::Prepared)
+ }
+ }
+ pub fn eval(&self, val: impl Into<Thunk<Val>>) -> Result<Val> {
+ match self {
+ KeyF::Identity => val.into().evaluate(),
+ KeyF::Prepared(p) => p.call(CallLocation::native(), &[val.into()], &[]),
+ KeyF::PrepareFailure(e) => Err(e.clone()),
+ }
+ }
+}
+
+impl Typed for KeyF {
+ const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
+ fn from_untyped(untyped: Val) -> Result<Self> {
+ FuncVal::from_untyped(untyped).map(Self::new)
+ }
+
+ fn into_untyped(_typed: Self) -> Result<Val> {
+ unreachable!("unused, todo: port split of Typed trait from #193")
+ }
+}
crates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -50,6 +50,7 @@
mod sort;
mod strings;
mod types;
+mod keyf;
#[allow(clippy::too_many_lines)]
pub fn stdlib_uncached(settings: Cc<RefCell<Settings>>) -> ObjValue {
crates/jrsonnet-stdlib/src/sets.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/sets.rs
+++ b/crates/jrsonnet-stdlib/src/sets.rs
@@ -1,28 +1,23 @@
use std::cmp::Ordering;
use jrsonnet_evaluator::{
- function::{builtin, FuncVal},
- operator::evaluate_compare_op,
- val::ArrValue,
- Result, Thunk, Val,
+ function::builtin, operator::evaluate_compare_op, val::ArrValue, Result, Thunk, Val,
};
use jrsonnet_parser::BinaryOpType;
+use crate::keyf::KeyF;
+
#[builtin]
#[allow(non_snake_case)]
-pub fn builtin_set_member(x: Thunk<Val>, arr: ArrValue, keyF: Option<FuncVal>) -> Result<bool> {
+pub fn builtin_set_member(x: Thunk<Val>, arr: ArrValue, #[default] keyF: KeyF) -> Result<bool> {
let mut low = 0;
let mut high = arr.len();
- let keyF = keyF
- .unwrap_or(FuncVal::Id)
- .into_native::<((Thunk<Val>,), Val)>();
-
- let x = keyF(x)?;
+ let x = keyF.eval(x)?;
while low < high {
let middle = usize::midpoint(high, low);
- let comp = keyF(arr.get_lazy(middle).expect("in bounds"))?;
+ let comp = keyF.eval(arr.get_lazy(middle).expect("in bounds"))?;
match evaluate_compare_op(&comp, &x, BinaryOpType::Lt)? {
Ordering::Less => low = middle + 1,
Ordering::Equal => return Ok(true),
@@ -34,14 +29,11 @@
#[builtin]
#[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_inter(a: ArrValue, b: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
+pub fn builtin_set_inter(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
let mut a = a.iter_lazy();
let mut b = b.iter_lazy();
- let keyF = keyF
- .unwrap_or(FuncVal::identity())
- .into_native::<((Thunk<Val>,), Val)>();
- let keyF = |v| keyF(v);
+ let keyF = |v| keyF.eval(v);
let mut av = a.next();
let mut bv = b.next();
@@ -73,14 +65,11 @@
#[builtin]
#[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_diff(a: ArrValue, b: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
+pub fn builtin_set_diff(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
let mut a = a.iter_lazy();
let mut b = b.iter_lazy();
- let keyF = keyF
- .unwrap_or(FuncVal::identity())
- .into_native::<((Thunk<Val>,), Val)>();
- let keyF = |v| keyF(v);
+ let keyF = |v| keyF.eval(v);
let mut av = a.next();
let mut bv = b.next();
@@ -119,14 +108,11 @@
#[builtin]
#[allow(non_snake_case, clippy::redundant_closure)]
-pub fn builtin_set_union(a: ArrValue, b: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
+pub fn builtin_set_union(a: ArrValue, b: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
let mut a = a.iter_lazy();
let mut b = b.iter_lazy();
- let keyF = keyF
- .unwrap_or(FuncVal::identity())
- .into_native::<((Thunk<Val>,), Val)>();
- let keyF = |v| keyF(v);
+ let keyF = |v| keyF.eval(v);
let mut av = a.next();
let mut bv = b.next();
crates/jrsonnet-stdlib/src/sort.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/sort.rs
+++ b/crates/jrsonnet-stdlib/src/sort.rs
@@ -4,14 +4,14 @@
use jrsonnet_evaluator::{
bail,
- function::{builtin, FuncVal},
+ function::builtin,
operator::evaluate_compare_op,
val::{equals, ArrValue},
Result, Thunk, Val,
};
use jrsonnet_parser::BinaryOpType;
-use crate::eval_on_empty;
+use crate::{eval_on_empty, keyf::KeyF};
#[derive(Copy, Clone)]
enum SortKeyType {
@@ -70,14 +70,11 @@
Ok(values)
}
-fn sort_keyf(values: ArrValue, keyf: FuncVal) -> Result<Vec<Thunk<Val>>> {
+fn sort_keyf(values: ArrValue, keyf: KeyF) -> Result<Vec<Thunk<Val>>> {
// Slow path, user provided key getter
let mut vk = Vec::with_capacity(values.len());
for value in values.iter_lazy() {
- vk.push((
- value.clone(),
- keyf.evaluate_simple(&(value.clone(),), false)?,
- ));
+ vk.push((value.clone(), keyf.eval(value)?));
}
let sort_type = get_sort_type(&vk, |v| &v.1)?;
match sort_type {
@@ -112,7 +109,7 @@
}
/// * `key_getter` - None, if identity sort required
-pub fn sort(values: ArrValue, key_getter: FuncVal) -> Result<ArrValue> {
+pub fn sort(values: ArrValue, key_getter: KeyF) -> Result<ArrValue> {
if values.len() <= 1 {
return Ok(values);
}
@@ -126,11 +123,7 @@
}
#[builtin]
-pub fn builtin_sort(
- arr: ArrValue,
-
- #[default(FuncVal::identity())] keyF: FuncVal,
-) -> Result<ArrValue> {
+pub fn builtin_sort(arr: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
super::sort::sort(arr, keyF)
}
@@ -147,14 +140,14 @@
Ok(out)
}
-fn uniq_keyf(arr: ArrValue, keyf: FuncVal) -> Result<Vec<Thunk<Val>>> {
+fn uniq_keyf(arr: ArrValue, keyf: KeyF) -> Result<Vec<Thunk<Val>>> {
let mut out = Vec::new();
let last_value = arr.get_lazy(0).unwrap();
- let mut last_key = keyf.evaluate_simple(&(last_value.clone(),), false)?;
+ let mut last_key = keyf.eval(last_value.clone())?;
out.push(last_value);
for next in arr.iter_lazy().skip(1) {
- let next_key = keyf.evaluate_simple(&(next.clone(),), false)?;
+ let next_key = keyf.eval(next.clone())?;
if !equals(&last_key, &next_key)? {
out.push(next.clone());
}
@@ -165,11 +158,7 @@
#[builtin]
#[allow(non_snake_case)]
-pub fn builtin_uniq(
- arr: ArrValue,
-
- #[default(FuncVal::identity())] keyF: FuncVal,
-) -> Result<ArrValue> {
+pub fn builtin_uniq(arr: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
if arr.len() <= 1 {
return Ok(arr);
}
@@ -184,11 +173,7 @@
#[builtin]
#[allow(non_snake_case)]
-pub fn builtin_set(
- arr: ArrValue,
-
- #[default(FuncVal::identity())] keyF: FuncVal,
-) -> Result<ArrValue> {
+pub fn builtin_set(arr: ArrValue, #[default] keyF: KeyF) -> Result<ArrValue> {
if arr.len() <= 1 {
return Ok(arr);
}
@@ -201,24 +186,16 @@
let arr = sort_keyf(arr, keyF.clone())?;
let arr = uniq_keyf(ArrValue::lazy(arr), keyF)?;
Ok(ArrValue::lazy(arr))
- }
-}
-
-fn eval_keyf(val: Val, key_f: Option<&FuncVal>) -> Result<Val> {
- if let Some(key_f) = key_f {
- key_f.evaluate_simple(&(val,), false)
- } else {
- Ok(val)
}
}
-fn array_top1(arr: ArrValue, key_f: Option<&FuncVal>, ordering: Ordering) -> Result<Val> {
+fn array_top1(arr: ArrValue, keyf: KeyF, ordering: Ordering) -> Result<Val> {
let mut iter = arr.iter();
let mut min = iter.next().expect("not empty")?;
- let mut min_key = eval_keyf(min.clone(), key_f)?;
+ let mut min_key = keyf.eval(Thunk::evaluated(min.clone()))?;
for item in iter {
let cur = item?;
- let cur_key = eval_keyf(cur.clone(), key_f)?;
+ let cur_key = keyf.eval(Thunk::evaluated(cur.clone()))?;
if evaluate_compare_op(&cur_key, &min_key, BinaryOpType::Lt)? == ordering {
min = cur;
min_key = cur_key;
@@ -230,22 +207,22 @@
#[builtin]
pub fn builtin_min_array(
arr: ArrValue,
- keyF: Option<FuncVal>,
+ #[default] keyF: KeyF,
onEmpty: Option<Thunk<Val>>,
) -> Result<Val> {
if arr.is_empty() {
return eval_on_empty(onEmpty);
}
- array_top1(arr, keyF.as_ref(), Ordering::Less)
+ array_top1(arr, keyF, Ordering::Less)
}
#[builtin]
pub fn builtin_max_array(
arr: ArrValue,
- keyF: Option<FuncVal>,
+ #[default] keyF: KeyF,
onEmpty: Option<Thunk<Val>>,
) -> Result<Val> {
if arr.is_empty() {
return eval_on_empty(onEmpty);
}
- array_top1(arr, keyF.as_ref(), Ordering::Greater)
+ array_top1(arr, keyF, Ordering::Greater)
}
tests/tests/builtin.rsdiffbeforeafterboth--- a/tests/tests/builtin.rs
+++ b/tests/tests/builtin.rs
@@ -18,8 +18,7 @@
#[test]
fn basic_function() -> Result<()> {
let a: a = a {};
- let v =
- u32::from_untyped(a.call(ContextBuilder::new().build(), CallLocation::native(), &())?)?;
+ let v = u32::from_untyped(a.call(CallLocation::native(), &[])?)?;
ensure_eq!(v, 1);
Ok(())