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)
 	}
 }
 

1use std::mem::replace;
2
1use jrsonnet_gcmodule::Trace;3use jrsonnet_gcmodule::Trace;
2use jrsonnet_interner::IStr;4use jrsonnet_interner::IStr;
3use jrsonnet_parser::{LocExpr, ParamsDesc};5use jrsonnet_parser::{LocExpr, ParamsDesc};
46
5use super::{7use super::{arglike::ArgsLike, builtin::BuiltinParam};
6	arglike::ArgsLike,
7	builtin::{BuiltinParam, BuiltinParamName},
8};
9use crate::{8use crate::{
10	destructure::destruct,9	destructure::destruct,
129							.0
130							.clone()
131							.name()
132							.unwrap_or_else(|| "<destruct>".into()),
133						params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()128						params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()
134					));129					));
135				}130				}
160	params: &[BuiltinParam],155	params: &[BuiltinParam],
161	args: &dyn ArgsLike,156	args: &dyn ArgsLike,
162	tailstrict: bool,157	tailstrict: bool,
163) -> Result<GcHashMap<BuiltinParamName, Thunk<Val>>> {158) -> Result<Vec<Option<Thunk<Val>>>> {
164	let mut passed_args = GcHashMap::with_capacity(params.len());159	let mut passed_args: Vec<Option<Thunk<Val>>> = vec![None; params.len()];
165	if args.unnamed_len() > params.len() {160	if args.unnamed_len() > params.len() {
166		throw!(TooManyArgsFunctionHas(161		throw!(TooManyArgsFunctionHas(
167			params.len(),162			params.len(),
168			params163			params
169				.iter()164				.iter()
170				.map(|p| (Some(p.name.as_ref().into()), p.has_default))165				.map(|p| (p.name.as_ref().map(|v| v.as_ref().into()), p.has_default))
171				.collect()166				.collect()
172		))167		))
173	}168	}
174169
175	let mut filled_args = 0;170	let mut filled_args = 0;
176171
177	args.unnamed_iter(s.clone(), ctx.clone(), tailstrict, &mut |id, arg| {172	args.unnamed_iter(s.clone(), ctx.clone(), tailstrict, &mut |id, arg| {
178		let name = params[id].name.clone();173		passed_args[id] = Some(arg);
179		passed_args.insert(name, arg);
180		filled_args += 1;174		filled_args += 1;
181		Ok(())175		Ok(())
182	})?;176	})?;
183177
184	args.named_iter(s, ctx, tailstrict, &mut |name, arg| {178	args.named_iter(s, ctx, tailstrict, &mut |name, arg| {
185		// FIXME: O(n) for arg existence check179		// FIXME: O(n) for arg existence check
186		let p = params180		let id = params
187			.iter()181			.iter()
188			.find(|p| p.name == name as &str)182			.position(|p| {
183				p.name
184					.as_ref()
185					.map(|v| &v as &str == name as &str)
186					.unwrap_or(false)
187			})
189			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;188			.ok_or_else(|| UnknownFunctionParameter((name as &str).to_owned()))?;
190		if passed_args.insert(p.name.clone(), arg).is_some() {189		if replace(&mut passed_args[id], Some(arg)).is_some() {
191			throw!(BindingParameterASecondTime(name.clone()));190			throw!(BindingParameterASecondTime(name.clone()));
192		}191		}
193		filled_args += 1;192		filled_args += 1;
194		Ok(())193		Ok(())
195	})?;194	})?;
196195
197	if filled_args < params.len() {196	if filled_args < params.len() {
198		for param in params.iter().filter(|p| p.has_default) {197		for (id, _) in params.iter().enumerate().filter(|(_, p)| p.has_default) {
199			if passed_args.contains_key(&param.name) {198			if passed_args[id].is_some() {
200				continue;199				continue;
201			}200			}
202			filled_args += 1;201			filled_args += 1;
207			for param in params.iter().skip(args.unnamed_len()) {206			for param in params.iter().skip(args.unnamed_len()) {
208				let mut found = false;207				let mut found = false;
209				args.named_names(&mut |name| {208				args.named_names(&mut |name| {
210					if name as &str == &param.name as &str {209					if param
210						.name
211						.as_ref()
212						.map(|v| &v as &str == name as &str)
213						.unwrap_or(false)
214					{
211						found = true;215						found = true;
212					}216					}
213				});217				});
214				if !found {218				if !found {
215					throw!(FunctionParameterNotBoundInCall(219					throw!(FunctionParameterNotBoundInCall(
216						param.name.clone().into(),220						param.name.as_ref().map(|v| v.as_ref().into()),
217						params221						params
218							.iter()222							.iter()
219							.map(|p| (Some(p.name.as_ref().into()), p.has_default))223							.map(|p| (p.name.as_ref().map(|p| p.as_ref().into()), p.has_default))
220							.collect()224							.collect()
221					));225					));
222				}226				}
236		type Output = Val;240		type Output = Val;
237		fn get(self: Box<Self>, _: State) -> Result<Val> {241		fn get(self: Box<Self>, _: State) -> Result<Val> {
238			Err(FunctionParameterNotBoundInCall(242			Err(FunctionParameterNotBoundInCall(
239				self.0.clone(),243				Some(self.0.clone()),
240				self.1.iter().map(|p| (p.0.name(), p.1.is_some())).collect(),244				self.1.iter().map(|p| (p.0.name(), p.1.is_some())).collect(),
241			)245			)
242			.into())246			.into())

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -122,13 +122,13 @@
 	Normal {
 		ty: Box<Type>,
 		is_option: bool,
-		name: String,
+		name: Option<String>,
 		cfg_attrs: Vec<Attribute>,
 		// ident: Ident,
 	},
 	Lazy {
 		is_option: bool,
-		name: String,
+		name: Option<String>,
 	},
 	State,
 	Location,
@@ -142,8 +142,8 @@
 			FnArg::Typed(a) => a,
 		};
 		let ident = match &arg.pat as &Pat {
-			Pat::Ident(i) => i.ident.clone(),
-			_ => return Err(Error::new(arg.pat.span(), "arg should be plain identifier")),
+			Pat::Ident(i) => Some(i.ident.clone()),
+			_ => None,
 		};
 		let ty = &arg.ty;
 		if type_is_path(ty, "State").is_some() {
@@ -153,7 +153,7 @@
 		} else if type_is_path(ty, "Thunk").is_some() {
 			return Ok(Self::Lazy {
 				is_option: false,
-				name: ident.to_string(),
+				name: ident.map(|v| v.to_string()),
 			});
 		}
 
@@ -166,7 +166,7 @@
 			if type_is_path(ty, "Thunk").is_some() {
 				return Ok(Self::Lazy {
 					is_option: true,
-					name: ident.to_string(),
+					name: ident.map(|v| v.to_string()),
 				});
 			}
 
@@ -185,7 +185,7 @@
 		Ok(Self::Normal {
 			ty,
 			is_option,
-			name: ident.to_string(),
+			name: ident.map(|v| v.to_string()),
 			cfg_attrs,
 		})
 	}
@@ -248,69 +248,95 @@
 			name,
 			cfg_attrs,
 			..
-		} => Some(quote! {
-			#(#cfg_attrs)*
-			BuiltinParam {
-				name: std::borrow::Cow::Borrowed(#name),
-				has_default: #is_option,
-			},
-		}),
-		ArgInfo::Lazy { is_option, name } => Some(quote! {
-			BuiltinParam {
-				name: std::borrow::Cow::Borrowed(#name),
-				has_default: #is_option,
-			},
-		}),
+		} => {
+			let name = name
+				.as_ref()
+				.map(|n| quote! {Some(std::borrow::Cow::Borrowed(#n))})
+				.unwrap_or_else(|| quote! {None});
+			Some(quote! {
+				#(#cfg_attrs)*
+				BuiltinParam {
+					name: #name,
+					has_default: #is_option,
+				},
+			})
+		}
+		ArgInfo::Lazy { is_option, name } => {
+			let name = name
+				.as_ref()
+				.map(|n| quote! {Some(std::borrow::Cow::Borrowed(#n))})
+				.unwrap_or_else(|| quote! {None});
+			Some(quote! {
+				BuiltinParam {
+					name: #name,
+					has_default: #is_option,
+				},
+			})
+		}
 		ArgInfo::State => None,
 		ArgInfo::Location => None,
 		ArgInfo::This => None,
 	});
 
-	let pass = args.iter().map(|a| match a {
-		ArgInfo::Normal {
-			ty,
-			is_option,
-			name,
-			cfg_attrs,
-		} => {
-			let eval = quote! {s.push_description(
-				|| format!("argument <{}> evaluation", #name),
-				|| <#ty>::from_untyped(value.evaluate(s.clone())?, s.clone()),
-			)?};
-			let value = if *is_option {
-				quote! {if let Some(value) = parsed.get(#name) {
-					Some(#eval)
+	let mut id = 0usize;
+	let pass = args
+		.iter()
+		.map(|a| match a {
+			ArgInfo::Normal { .. } | ArgInfo::Lazy { .. } => {
+				let cid = id;
+				id += 1;
+				(quote! {#cid}, a)
+			}
+			ArgInfo::State | ArgInfo::Location | ArgInfo::This => {
+				(quote! {compile_error!("should not use id")}, a)
+			}
+		})
+		.map(|(id, a)| match a {
+			ArgInfo::Normal {
+				ty,
+				is_option,
+				name,
+				cfg_attrs,
+			} => {
+				let name = name.as_ref().map(|v| v.as_str()).unwrap_or("<unnamed>");
+				let eval = quote! {s.push_description(
+					|| format!("argument <{}> evaluation", #name),
+					|| <#ty>::from_untyped(value.evaluate(s.clone())?, s.clone()),
+				)?};
+				let value = if *is_option {
+					quote! {if let Some(value) = &parsed[#id] {
+						Some(#eval)
+					} else {
+						None
+					},}
 				} else {
-					None
-				},}
-			} else {
-				quote! {{
-					let value = parsed.get(#name).expect("args shape is checked");
-					#eval
-				},}
-			};
-			quote! {
-				#(#cfg_attrs)*
-				#value
+					quote! {{
+						let value = parsed[#id].as_ref().expect("args shape is checked");
+						#eval
+					},}
+				};
+				quote! {
+					#(#cfg_attrs)*
+					#value
+				}
 			}
-		}
-		ArgInfo::Lazy { is_option, name } => {
-			if *is_option {
-				quote! {if let Some(value) = parsed.get(#name) {
-					Some(value.clone())
+			ArgInfo::Lazy { is_option, .. } => {
+				if *is_option {
+					quote! {if let Some(value) = &parsed[#id] {
+						Some(value.clone())
+					} else {
+						None
+					}}
 				} else {
-					None
-				}}
-			} else {
-				quote! {
-					parsed.get(#name).expect("args shape is correct").clone(),
+					quote! {
+						parsed[#id].as_ref().expect("args shape is correct").clone(),
+					}
 				}
 			}
-		}
-		ArgInfo::State => quote! {s.clone(),},
-		ArgInfo::Location => quote! {location,},
-		ArgInfo::This => quote! {self,},
-	});
+			ArgInfo::State => quote! {s.clone(),},
+			ArgInfo::Location => quote! {location,},
+			ArgInfo::This => quote! {self,},
+		});
 
 	let fields = attr.fields.iter().map(|field| {
 		let name = &field.name;