git.delta.rocks / jrsonnet / refs/commits / afca25294a05

--- a/bindings/jsonnet/src/native.rs
+++ b/bindings/jsonnet/src/native.rs
@@ -1,11 +1,12 @@
 use std::{
+	borrow::Cow,
 	ffi::{c_void, CStr},
 	os::raw::{c_char, c_int},
 };
 
 use jrsonnet_evaluator::{
 	error::{Error, LocError},
-	function::builtin::{BuiltinParam, NativeCallback, NativeCallbackHandler},
+	function::builtin::{NativeCallback, NativeCallbackHandler},
 	tb,
 	typed::Typed,
 	IStr, State, Val,
@@ -87,10 +88,7 @@
 		let param = CStr::from_ptr(*raw_params)
 			.to_str()
 			.expect("param name is not utf-8");
-		params.push(BuiltinParam {
-			name: param.into(),
-			has_default: false,
-		});
+		params.push(Cow::Owned(param.into()));
 		raw_params = raw_params.offset(1);
 	}
 

--- a/crates/jrsonnet-evaluator/src/error.rs
+++ b/crates/jrsonnet-evaluator/src/error.rs
@@ -113,8 +113,8 @@
 	BindingParameterASecondTime(IStr),
 	#[error("too many args, function has {0}{}", format_signature(.1))]
 	TooManyArgsFunctionHas(usize, FunctionSignature),
-	#[error("function argument is not passed: {0}{}", format_signature(.1))]
-	FunctionParameterNotBoundInCall(IStr, FunctionSignature),
+	#[error("function argument is not passed: {}{}", .0.as_ref().map(|n| n.as_str()).unwrap_or("<unnamed>"), format_signature(.1))]
+	FunctionParameterNotBoundInCall(Option<IStr>, FunctionSignature),
 
 	#[error("external variable is not defined: {0}")]
 	UndefinedExternalVariable(IStr),

--- a/crates/jrsonnet-evaluator/src/function/builtin.rs
+++ b/crates/jrsonnet-evaluator/src/function/builtin.rs
@@ -9,7 +9,9 @@
 
 #[derive(Clone, Trace)]
 pub struct BuiltinParam {
-	pub name: BuiltinParamName,
+	/// Parameter name for named call parsing
+	pub name: Option<BuiltinParamName>,
+	/// Is implementation allowed to return empty value
 	pub has_default: bool,
 }
 
@@ -40,8 +42,20 @@
 }
 impl NativeCallback {
 	#[deprecated = "prefer using builtins directly, use this interface only for bindings"]
-	pub fn new(params: Vec<BuiltinParam>, handler: TraceBox<dyn NativeCallbackHandler>) -> Self {
-		Self { params, handler }
+	pub fn new(
+		params: Vec<Cow<'static, str>>,
+		handler: TraceBox<dyn NativeCallbackHandler>,
+	) -> Self {
+		Self {
+			params: params
+				.into_iter()
+				.map(|n| BuiltinParam {
+					name: Some(n),
+					has_default: false,
+				})
+				.collect(),
+			handler,
+		}
 	}
 }
 
@@ -58,11 +72,12 @@
 
 	fn call(&self, s: State, ctx: Context, _loc: CallLocation, args: &dyn ArgsLike) -> Result<Val> {
 		let args = parse_builtin_call(s.clone(), ctx, &self.params, args, true)?;
-		let mut out_args = Vec::with_capacity(self.params.len());
-		for p in &self.params {
-			out_args.push(args[&p.name].evaluate(s.clone())?);
-		}
-		self.handler.call(s, &out_args)
+		let args = args
+			.into_iter()
+			.map(|a| a.expect("legacy natives have no default params"))
+			.map(|a| a.evaluate(s.clone()))
+			.collect::<Result<Vec<Val>>>()?;
+		self.handler.call(s, &args)
 	}
 }
 

--- a/crates/jrsonnet-evaluator/src/function/parse.rs
+++ b/crates/jrsonnet-evaluator/src/function/parse.rs
@@ -1,11 +1,10 @@
+use std::mem::replace;
+
 use jrsonnet_gcmodule::Trace;
 use jrsonnet_interner::IStr;
 use jrsonnet_parser::{LocExpr, ParamsDesc};
 
-use super::{
-	arglike::ArgsLike,
-	builtin::{BuiltinParam, BuiltinParamName},
-};
+use super::{arglike::ArgsLike, builtin::BuiltinParam};
 use crate::{
 	destructure::destruct,
 	error::{Error::*, Result},
@@ -125,11 +124,7 @@
 				});
 				if !found {
 					throw!(FunctionParameterNotBoundInCall(
-						param
-							.0
-							.clone()
-							.name()
-							.unwrap_or_else(|| "<destruct>".into()),
+						param.0.clone().name(),
 						params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()
 					));
 				}
@@ -160,14 +155,14 @@
 	params: &[BuiltinParam],
 	args: &dyn ArgsLike,
 	tailstrict: bool,
-) -> Result<GcHashMap<BuiltinParamName, Thunk<Val>>> {
-	let mut passed_args = GcHashMap::with_capacity(params.len());
+) -> Result<Vec<Option<Thunk<Val>>>> {
+	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];
 	if args.unnamed_len() > params.len() {
 		throw!(TooManyArgsFunctionHas(
 			params.len(),
 			params
 				.iter()
-				.map(|p| (Some(p.name.as_ref().into()), p.has_default))
+				.map(|p| (p.name.as_ref().map(|v| v.as_ref().into()), p.has_default))
 				.collect()
 		))
 	}
@@ -175,19 +170,23 @@
 	let mut filled_args = 0;
 
 	args.unnamed_iter(s.clone(), ctx.clone(), tailstrict, &mut |id, arg| {
-		let name = params[id].name.clone();
-		passed_args.insert(name, arg);
+		passed_args[id] = Some(arg);
 		filled_args += 1;
 		Ok(())
 	})?;
 
 	args.named_iter(s, ctx, tailstrict, &mut |name, arg| {
 		// FIXME: O(n) for arg existence check
-		let p = params
+		let id = params
 			.iter()
-			.find(|p| p.name == name as &str)
+			.position(|p| {
+				p.name
+					.as_ref()
+					.map(|v| &v as &str == name as &str)
+					.unwrap_or(false)
+			})
 			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
-		if passed_args.insert(p.name.clone(), arg).is_some() {
+		if replace(&mut passed_args[id], Some(arg)).is_some() {
 			throw!(BindingParameterASecondTime(name.clone()));
 		}
 		filled_args += 1;
@@ -195,8 +194,8 @@
 	})?;
 
 	if filled_args < params.len() {
-		for param in params.iter().filter(|p| p.has_default) {
-			if passed_args.contains_key(&param.name) {
+		for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default) {
+			if passed_args[id].is_some() {
 				continue;
 			}
 			filled_args += 1;
@@ -207,16 +206,21 @@
 			for param in params.iter().skip(args.unnamed_len()) {
 				let mut found = false;
 				args.named_names(&mut |name| {
-					if name as &str == &param.name as &str {
+					if param
+						.name
+						.as_ref()
+						.map(|v| &v as &str == name as &str)
+						.unwrap_or(false)
+					{
 						found = true;
 					}
 				});
 				if !found {
 					throw!(FunctionParameterNotBoundInCall(
-						param.name.clone().into(),
+						param.name.as_ref().map(|v| v.as_ref().into()),
 						params
 							.iter()
-							.map(|p| (Some(p.name.as_ref().into()), p.has_default))
+							.map(|p| (p.name.as_ref().map(|p| p.as_ref().into()), p.has_default))
 							.collect()
 					));
 				}
@@ -236,7 +240,7 @@
 		type Output = Val;
 		fn get(self: Box<Self>, _: State) -> Result<Val> {
 			Err(FunctionParameterNotBoundInCall(
-				self.0.clone(),
+				Some(self.0.clone()),
 				self.1.iter().map(|p| (p.0.name(), p.1.is_some())).collect(),
 			)
 			.into())

122	Normal {122	Normal {
123		ty: Box<Type>,123		ty: Box<Type>,
124		is_option: bool,124		is_option: bool,
125		name: String,125		name: Option<String>,
126		cfg_attrs: Vec<Attribute>,126		cfg_attrs: Vec<Attribute>,
127		// ident: Ident,127		// ident: Ident,
128	},128	},
129	Lazy {129	Lazy {
130		is_option: bool,130		is_option: bool,
131		name: String,131		name: Option<String>,
132	},132	},
133	State,133	State,
134	Location,134	Location,
142			FnArg::Typed(a) => a,142			FnArg::Typed(a) => a,
143		};143		};
144		let ident = match &arg.pat as &Pat {144		let ident = match &arg.pat as &Pat {
145			Pat::Ident(i) => i.ident.clone(),145			Pat::Ident(i) => Some(i.ident.clone()),
146			_ => return Err(Error::new(arg.pat.span(), "arg should be plain identifier")),146			_ => None,
147		};147		};
148		let ty = &arg.ty;148		let ty = &arg.ty;
149		if type_is_path(ty, "State").is_some() {149		if type_is_path(ty, "State").is_some() {
153		} else if type_is_path(ty, "Thunk").is_some() {153		} else if type_is_path(ty, "Thunk").is_some() {
154			return Ok(Self::Lazy {154			return Ok(Self::Lazy {
155				is_option: false,155				is_option: false,
156				name: ident.to_string(),156				name: ident.map(|v| v.to_string()),
157			});157			});
158		}158		}
159159
166			if type_is_path(ty, "Thunk").is_some() {166			if type_is_path(ty, "Thunk").is_some() {
167				return Ok(Self::Lazy {167				return Ok(Self::Lazy {
168					is_option: true,168					is_option: true,
169					name: ident.to_string(),169					name: ident.map(|v| v.to_string()),
170				});170				});
171			}171			}
172172
185		Ok(Self::Normal {185		Ok(Self::Normal {
186			ty,186			ty,
187			is_option,187			is_option,
188			name: ident.to_string(),188			name: ident.map(|v| v.to_string()),
189			cfg_attrs,189			cfg_attrs,
190		})190		})
191	}191	}
248			name,248			name,
249			cfg_attrs,249			cfg_attrs,
250			..250			..
251		} => Some(quote! {251		} => {
252			let name = name
253				.as_ref()
254				.map(|n| quote! {Some(std::borrow::Cow::Borrowed(#n))})
255				.unwrap_or_else(|| quote! {None});
256			Some(quote! {
252			#(#cfg_attrs)*257				#(#cfg_attrs)*
253			BuiltinParam {258				BuiltinParam {
254				name: std::borrow::Cow::Borrowed(#name),259					name: #name,
255				has_default: #is_option,260					has_default: #is_option,
256			},261				},
257		}),262			})
263		}
258		ArgInfo::Lazy { is_option, name } => Some(quote! {264		ArgInfo::Lazy { is_option, name } => {
265			let name = name
266				.as_ref()
267				.map(|n| quote! {Some(std::borrow::Cow::Borrowed(#n))})
268				.unwrap_or_else(|| quote! {None});
269			Some(quote! {
259			BuiltinParam {270				BuiltinParam {
260				name: std::borrow::Cow::Borrowed(#name),271					name: #name,
261				has_default: #is_option,272					has_default: #is_option,
262			},273				},
263		}),274			})
275		}
264		ArgInfo::State => None,276		ArgInfo::State => None,
265		ArgInfo::Location => None,277		ArgInfo::Location => None,
266		ArgInfo::This => None,278		ArgInfo::This => None,
267	});279	});
268280
281	let mut id = 0usize;
269	let pass = args.iter().map(|a| match a {282	let pass = args
283		.iter()
284		.map(|a| match a {
285			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {
286				let cid = id;
287				id += 1;
288				(quote! {#cid}, a)
289			}
290			ArgInfo::State | ArgInfo::Location | ArgInfo::This => {
291				(quote! {compile_error!("should not use id")}, a)
292			}
293		})
294		.map(|(id, a)| match a {
270		ArgInfo::Normal {295			ArgInfo::Normal {
271			ty,296				ty,
272			is_option,297				is_option,
273			name,298				name,
274			cfg_attrs,299				cfg_attrs,
275		} => {300			} => {
301				let name = name.as_ref().map(|v| v.as_str()).unwrap_or("<unnamed>");
276			let eval = quote! {s.push_description(302				let eval = quote! {s.push_description(
277				|| format!("argument <{}> evaluation", #name),303					|| format!("argument <{}> evaluation", #name),
278				|| <#ty>::from_untyped(value.evaluate(s.clone())?, s.clone()),304					|| <#ty>::from_untyped(value.evaluate(s.clone())?, s.clone()),
279			)?};305				)?};
280			let value = if *is_option {306				let value = if *is_option {
281				quote! {if let Some(value) = parsed.get(#name) {307					quote! {if let Some(value) = &parsed[#id] {
282					Some(#eval)308						Some(#eval)
283				} else {309					} else {
284					None310						None
285				},}311					},}
286			} else {312				} else {
287				quote! {{313					quote! {{
288					let value = parsed.get(#name).expect("args shape is checked");314						let value = parsed[#id].as_ref().expect("args shape is checked");
289					#eval315						#eval
290				},}316					},}
291			};317				};
294				#value320					#value
295			}321				}
296		}322			}
297		ArgInfo::Lazy { is_option, name } => {323			ArgInfo::Lazy { is_option, .. } => {
298			if *is_option {324				if *is_option {
299				quote! {if let Some(value) = parsed.get(#name) {325					quote! {if let Some(value) = &parsed[#id] {
300					Some(value.clone())326						Some(value.clone())
301				} else {327					} else {
302					None328						None
303				}}329					}}
304			} else {330				} else {
305				quote! {331					quote! {
306					parsed.get(#name).expect("args shape is correct").clone(),332						parsed[#id].as_ref().expect("args shape is correct").clone(),
307				}333					}
308			}334				}
309		}335			}