difftreelog
refactor fancier builtin param type
in: master
5 files changed
bindings/jsonnet/src/native.rsdiffbeforeafterboth--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -1,5 +1,4 @@
use std::{
- borrow::Cow,
ffi::{c_void, CStr},
os::raw::{c_char, c_int},
};
@@ -82,7 +81,7 @@
let param = CStr::from_ptr(*raw_params)
.to_str()
.expect("param name is not utf-8");
- params.push(Cow::Owned(param.into()));
+ params.push(param.into());
raw_params = raw_params.offset(1);
}
crates/jrsonnet-evaluator/src/function/builtin.rsdiffbeforeafterboth1use std::{any::Any, borrow::Cow};23use jrsonnet_gcmodule::Trace;45use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};6use crate::{error::Result, gc::TraceBox, tb, Context, Val};78pub type BuiltinParamName = Cow<'static, str>;910#[derive(Clone, Trace)]11pub struct BuiltinParam {12 /// Parameter name for named call parsing13 pub name: Option<BuiltinParamName>,14 /// Is implementation allowed to return empty value15 pub has_default: bool,16}1718/// Description of function defined by native code19///20/// Prefer to use #[builtin] macro, instead of manual implementation of this trait21pub trait Builtin: Trace {22 /// Function name to be used in stack traces23 fn name(&self) -> &str;24 /// Parameter names for named calls25 fn params(&self) -> &[BuiltinParam];26 /// Call the builtin27 fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val>;2829 fn as_any(&self) -> &dyn Any;30}3132pub trait StaticBuiltin: Builtin + Send + Sync33where34 Self: 'static,35{36 // In impl, to make it object safe:37 // const INST: &'static Self;38}3940#[derive(Trace)]41pub struct NativeCallback {42 pub(crate) params: Vec<BuiltinParam>,43 handler: TraceBox<dyn NativeCallbackHandler>,44}45impl NativeCallback {46 #[deprecated = "prefer using builtins directly, use this interface only for bindings"]47 pub fn new(params: Vec<Cow<'static, str>>, handler: impl NativeCallbackHandler) -> Self {48 Self {49 params: params50 .into_iter()51 .map(|n| BuiltinParam {52 name: Some(n),53 has_default: false,54 })55 .collect(),56 handler: tb!(handler),57 }58 }59}6061impl Builtin for NativeCallback {62 fn name(&self) -> &str {63 // TODO: standard natives gets their names from definition64 // But builitins should already have them65 "<native>"66 }6768 fn params(&self) -> &[BuiltinParam] {69 &self.params70 }7172 fn call(&self, ctx: Context, _loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {73 let args = parse_builtin_call(ctx, &self.params, args, true)?;74 let args = args75 .into_iter()76 .map(|a| a.expect("legacy natives have no default params"))77 .map(|a| a.evaluate())78 .collect::<Result<Vec<Val>>>()?;79 self.handler.call(&args)80 }8182 fn as_any(&self) -> &dyn Any {83 self84 }85}8687pub trait NativeCallbackHandler: Trace {88 fn call(&self, args: &[Val]) -> Result<Val>;89}1use std::{any::Any, borrow::Cow};23use jrsonnet_gcmodule::Trace;4use jrsonnet_interner::IStr;56use super::{arglike::ArgsLike, parse::parse_builtin_call, CallLocation};7use crate::{error::Result, gc::TraceBox, tb, Context, Val};89/// Can't have str | IStr, because constant BuiltinParam causes10/// E0492: constant functions cannot refer to interior mutable data11#[derive(Clone, Trace)]12pub struct ParamName(Option<Cow<'static, str>>);13impl ParamName {14 pub const ANONYMOUS: Self = Self(None);15 pub const fn new_static(name: &'static str) -> Self {16 Self(Some(Cow::Borrowed(name)))17 }18 pub fn new_dynamic(name: String) -> Self {19 Self(Some(Cow::Owned(name)))20 }21 pub fn as_str(&self) -> Option<&str> {22 self.0.as_deref()23 }24 pub fn is_anonymous(&self) -> bool {25 self.0.is_none()26 }27}28impl PartialEq<IStr> for ParamName {29 fn eq(&self, other: &IStr) -> bool {30 match &self.0 {31 Some(s) => s.as_bytes() == other.as_bytes(),32 None => false,33 }34 }35}3637#[derive(Clone, Trace)]38pub struct BuiltinParam {39 name: ParamName,40 has_default: bool,41}42impl BuiltinParam {43 pub const fn new(name: ParamName, has_default: bool) -> Self {44 Self { name, has_default }45 }46 /// Parameter name for named call parsing47 pub fn name(&self) -> &ParamName {48 &self.name49 }50 /// Is implementation allowed to return empty value51 pub fn has_default(&self) -> bool {52 self.has_default53 }54}5556/// Description of function defined by native code57///58/// Prefer to use #[builtin] macro, instead of manual implementation of this trait59pub trait Builtin: Trace {60 /// Function name to be used in stack traces61 fn name(&self) -> &str;62 /// Parameter names for named calls63 fn params(&self) -> &[BuiltinParam];64 /// Call the builtin65 fn call(&self, ctx: Context, loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val>;6667 fn as_any(&self) -> &dyn Any;68}6970pub trait StaticBuiltin: Builtin + Send + Sync71where72 Self: 'static,73{74 // In impl, to make it object safe:75 // const INST: &'static Self;76}7778#[derive(Trace)]79pub struct NativeCallback {80 pub(crate) params: Vec<BuiltinParam>,81 handler: TraceBox<dyn NativeCallbackHandler>,82}83impl NativeCallback {84 #[deprecated = "prefer using builtins directly, use this interface only for bindings"]85 pub fn new(params: Vec<String>, handler: impl NativeCallbackHandler) -> Self {86 Self {87 params: params88 .into_iter()89 .map(|n| BuiltinParam {90 name: ParamName::new_dynamic(n.to_string()),91 has_default: false,92 })93 .collect(),94 handler: tb!(handler),95 }96 }97}9899impl Builtin for NativeCallback {100 fn name(&self) -> &str {101 // TODO: standard natives gets their names from definition102 // But builitins should already have them103 "<native>"104 }105106 fn params(&self) -> &[BuiltinParam] {107 &self.params108 }109110 fn call(&self, ctx: Context, _loc: CallLocation<'_>, args: &dyn ArgsLike) -> Result<Val> {111 let args = parse_builtin_call(ctx, &self.params, args, true)?;112 let args = args113 .into_iter()114 .map(|a| a.expect("legacy natives have no default params"))115 .map(|a| a.evaluate())116 .collect::<Result<Vec<Val>>>()?;117 self.handler.call(&args)118 }119120 fn as_any(&self) -> &dyn Any {121 self122 }123}124125pub trait NativeCallbackHandler: Trace {126 fn call(&self, args: &[Val]) -> Result<Val>;127}crates/jrsonnet-evaluator/src/function/mod.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/mod.rs
+++ b/crates/jrsonnet-evaluator/src/function/mod.rs
@@ -8,7 +8,7 @@
use self::{
arglike::OptionalContext,
- builtin::{Builtin, StaticBuiltin},
+ builtin::{Builtin, BuiltinParam, ParamName, StaticBuiltin},
native::NativeDesc,
parse::{parse_default_function_call, parse_function_call},
};
@@ -113,17 +113,45 @@
}
}
+#[allow(clippy::unnecessary_wraps)]
+#[builtin]
+const fn builtin_id(x: Val) -> Val {
+ x
+}
+static ID: &builtin_id = &builtin_id {};
+
impl FuncVal {
pub fn builtin(builtin: impl Builtin) -> Self {
Self::Builtin(Cc::new(tb!(builtin)))
}
+
+ pub fn params(&self) -> Vec<BuiltinParam> {
+ match self {
+ Self::Id => ID.params().to_vec(),
+ Self::StaticBuiltin(i) => i.params().to_vec(),
+ Self::Builtin(i) => i.params().to_vec(),
+ Self::Normal(p) => p
+ .params
+ .iter()
+ .map(|p| {
+ BuiltinParam::new(
+ p.0.name()
+ .as_ref()
+ .map(IStr::to_string)
+ .map_or(ParamName::ANONYMOUS, ParamName::new_dynamic),
+ p.1.is_some(),
+ )
+ })
+ .collect(),
+ }
+ }
/// Amount of non-default required arguments
pub fn params_len(&self) -> usize {
match self {
Self::Id => 1,
Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),
- Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),
- Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),
+ Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
+ Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default()).count(),
}
}
/// Function name, as defined in code.
@@ -146,16 +174,7 @@
tailstrict: bool,
) -> Result<Val> {
match self {
- Self::Id => {
- #[allow(clippy::unnecessary_wraps)]
- #[builtin]
- const fn builtin_id(x: Val) -> Val {
- x
- }
- static ID: &builtin_id = &builtin_id {};
-
- ID.call(call_ctx, loc, args)
- }
+ 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)
crates/jrsonnet-evaluator/src/function/parse.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -163,7 +163,7 @@
params.len(),
params
.iter()
- .map(|p| (p.name.as_ref().map(|v| v.as_ref().into()), p.has_default))
+ .map(|p| (p.name().as_str().map(IStr::from), p.has_default()))
.collect()
))
}
@@ -180,7 +180,7 @@
// FIXME: O(n) for arg existence check
let id = params
.iter()
- .position(|p| p.name.as_ref().map_or(false, |v| v as &str == name as &str))
+ .position(|p| p.name() == name)
.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
if replace(&mut passed_args[id], Some(arg)).is_some() {
throw!(BindingParameterASecondTime(name.clone()));
@@ -190,7 +190,7 @@
})?;
if filled_args < params.len() {
- for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default) {
+ for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default()) {
if passed_args[id].is_some() {
continue;
}
@@ -202,20 +202,16 @@
for param in params.iter().skip(args.unnamed_len()) {
let mut found = false;
args.named_names(&mut |name| {
- if param
- .name
- .as_ref()
- .map_or(false, |v| v as &str == name as &str)
- {
+ if param.name() == name {
found = true;
}
});
if !found {
throw!(FunctionParameterNotBoundInCall(
- param.name.as_ref().map(|v| v.as_ref().into()),
+ param.name().as_str().map(IStr::from),
params
.iter()
- .map(|p| (p.name.as_ref().map(|p| p.as_ref().into()), p.has_default))
+ .map(|p| (p.name().as_str().map(IStr::from), p.has_default()))
.collect()
));
}
tests/tests/common.rsdiffbeforeafterboth--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -1,5 +1,3 @@
-use std::borrow::Cow;
-
use jrsonnet_evaluator::{
error::Result,
function::{builtin, FuncVal},
@@ -66,22 +64,12 @@
FuncVal::StaticBuiltin(b) => b
.params()
.iter()
- .map(|p| {
- p.name
- .as_ref()
- .unwrap_or(&Cow::Borrowed("<unnamed>"))
- .to_string()
- })
+ .map(|p| p.name().as_str().unwrap_or(&"<unnamed>").to_string())
.collect(),
FuncVal::Builtin(b) => b
.params()
.iter()
- .map(|p| {
- p.name
- .as_ref()
- .unwrap_or(&Cow::Borrowed("<unnamed>"))
- .to_string()
- })
+ .map(|p| p.name().as_str().unwrap_or(&"<unnamed>").to_string())
.collect(),
}
}