`6bf55d21bf51`

5 files changed

modifiedcrates/jrsonnet-evaluator/src/error.rsdiff before after both

11use thiserror::Error;11use thiserror::Error;
1212
13use crate::{function::CallLocation, stdlib::format::FormatError, typed::TypeLocError, ObjValue};13use crate::{
14	function::{builtin::ParamDefault, CallLocation},
15	stdlib::format::FormatError,
16	typed::TypeLocError,
17	ObjValue,
18};
1419
15pub(crate) fn format_found(list: &[IStr], what: &str) -> String {20pub(crate) fn format_found(list: &[IStr], what: &str) -> String {
43	if sig.is_empty() {48	if sig.is_empty() {
44		out.push_str("/*no arguments*/");49		out.push_str("/*no arguments*/");
45	} else {50	} else {
46		for (i, (name, has_default)) in sig.iter().enumerate() {51		for (i, (name, default)) in sig.iter().enumerate() {
47			if i != 0 {52			if i != 0 {
48				out.push_str(", ");53				out.push_str(", ");
49			}54			}
52			} else {57			} else {
53				out.push_str("<unnamed>");58				out.push_str("<unnamed>");
54			}59			}
60			match default {
61				ParamDefault::None => {}
62				ParamDefault::Exists => out.push_str(" = <default>"),
55			if *has_default {63				ParamDefault::Literal(lit) => {
56				out.push_str(" = <default>");64					out.push_str(" = ");
65					out.push_str(lit);
57			}66				}
67			}
58		}68		}
59	}69	}
60	out.push(')');70	out.push(')');
88	heap.into_iter().map(|v| v.1).collect()98	heap.into_iter().map(|v| v.1).collect()
89}99}
90100
91type FunctionSignature = Vec<(Option<IStr>, bool)>;101type FunctionSignature = Vec<(Option<IStr>, ParamDefault)>;
92102
93/// Possible errors103/// Possible errors
94#[allow(missing_docs)]104#[allow(missing_docs)]

modifiedcrates/jrsonnet-evaluator/src/function/builtin.rsdiff before after both

33	}33	}
34}34}
35
36#[derive(Clone, Copy, Debug, Trace)]
37pub enum ParamDefault {
38	None,
39	Exists,
40	Literal(&'static str),
41}
42impl ParamDefault {
43	pub const fn exists(is_exists: bool) -> Self {
44		if is_exists {
45			Self::Exists
46		} else {
47			Self::None
48		}
49	}
50}
3551
36#[derive(Clone, Trace)]52#[derive(Clone, Trace)]
37pub struct BuiltinParam {53pub struct BuiltinParam {
38	name: ParamName,54	name: ParamName,
39	has_default: bool,55	default: ParamDefault,
40}56}
41impl BuiltinParam {57impl BuiltinParam {
42	pub const fn new(name: ParamName, has_default: bool) -> Self {58	pub const fn new(name: ParamName, default: ParamDefault) -> Self {
43		Self { name, has_default }59		Self { name, default }
44	}60	}
45	/// Parameter name for named call parsing61	/// Parameter name for named call parsing
46	pub fn name(&self) -> &ParamName {62	pub fn name(&self) -> &ParamName {
47		&self.name63		&self.name
48	}64	}
49	/// Is implementation allowed to return empty value65	pub fn default(&self) -> ParamDefault {
66		self.default
67	}
50	pub fn has_default(&self) -> bool {68	pub fn has_default(&self) -> bool {
51		self.has_default69		!matches!(self.default, ParamDefault::None)
52	}70	}
53}71}
5472
87				.into_iter()105				.into_iter()
88				.map(|n| BuiltinParam {106				.map(|n| BuiltinParam {
89					name: ParamName::new_dynamic(n),107					name: ParamName::new_dynamic(n),
90					has_default: false,108					default: ParamDefault::Exists,
91				})109				})
92				.collect(),110				.collect(),
93			handler: tb!(handler),111			handler: tb!(handler),

modifiedcrates/jrsonnet-evaluator/src/function/mod.rsdiff before after both

88
9use self::{9use self::{
10	arglike::OptionalContext,10	arglike::OptionalContext,
11	builtin::{Builtin, BuiltinParam, ParamName, StaticBuiltin},11	builtin::{Builtin, BuiltinParam, ParamDefault, ParamName, StaticBuiltin},
12	native::NativeDesc,12	native::NativeDesc,
13	parse::{parse_default_function_call, parse_function_call},13	parse::{parse_default_function_call, parse_function_call},
14};14};
142							.as_ref()142							.as_ref()
143							.map(IStr::to_string)143							.map(IStr::to_string)
144							.map_or(ParamName::ANONYMOUS, ParamName::new_dynamic),144							.map_or(ParamName::ANONYMOUS, ParamName::new_dynamic),
145						p.1.is_some(),145						ParamDefault::exists(p.1.is_some()),
146					)146					)
147				})147				})
148				.collect(),148				.collect(),

modifiedcrates/jrsonnet-evaluator/src/function/parse.rsdiff before after both

10	destructure::destruct,10	destructure::destruct,
11	error::{ErrorKind::*, Result},11	error::{ErrorKind::*, Result},
12	evaluate_named,12	evaluate_named,
13	function::builtin::ParamDefault,
13	gc::GcHashMap,14	gc::GcHashMap,
14	val::ThunkValue,15	val::ThunkValue,
15	Context, Pending, Thunk, Val,16	Context, Pending, Thunk, Val,
51			params.len(),52			params.len(),
52			params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()53			params
54				.iter()
55				.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
56				.collect()
53		))57		))
54	}58	}
129						param.0.clone().name(),133						param.0.clone().name(),
130						params.iter().map(|p| (p.0.name(), p.1.is_some())).collect()134						params
135							.iter()
136							.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
137							.collect()
131					));138					));
132				}139				}
163			params.len(),170			params.len(),
164			params171			params
165				.iter()172				.iter()
166				.map(|p| (p.name().as_str().map(IStr::from), p.has_default()))173				.map(|p| (p.name().as_str().map(IStr::from), p.default()))
167				.collect()174				.collect()
168		))175		))
169	}176	}
211						param.name().as_str().map(IStr::from),218						param.name().as_str().map(IStr::from),
212						params219						params
213							.iter()220							.iter()
214							.map(|p| (p.name().as_str().map(IStr::from), p.has_default()))221							.map(|p| (p.name().as_str().map(IStr::from), p.default()))
215							.collect()222							.collect()
216					));223					));
217				}224				}
234				Some(self.0.clone()),241				Some(self.0.clone()),
235				self.1.iter().map(|p| (p.0.name(), p.1.is_some())).collect(),242				self.1
243					.iter()
244					.map(|p| (p.0.name(), ParamDefault::exists(p.1.is_some())))
245					.collect(),
236			)246			)
237			.into())247			.into())

modifiedcrates/jrsonnet-macros/src/lib.rsdiff before after both

253			let name = name253			let name = name
254				.as_ref()254				.as_ref()
255				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});255				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});
256			let is_optional = optionality.is_optional();256			let default = match optionality {
257				Optionality::Required => quote!(ParamDefault::None),
258				Optionality::Optional => quote!(ParamDefault::Exists),
259				Optionality::Default(e) => quote!(ParamDefault::Literal(stringify!(#e))),
260			};
257			Some(quote! {261			Some(quote! {
258				#(#cfg_attrs)*262				#(#cfg_attrs)*
259				BuiltinParam::new(#name, #is_optional),263				BuiltinParam::new(#name, #default),
260			})264			})
261		}265		}
262		ArgInfo::Lazy { is_option, name } => {266		ArgInfo::Lazy { is_option, name } => {
263			let name = name267			let name = name
264				.as_ref()268				.as_ref()
265				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});269				.map_or_else(|| quote! {None}, |n| quote! {ParamName::new_static(#n)});
266			Some(quote! {270			Some(quote! {
267				BuiltinParam::new(#name, #is_option),271				BuiltinParam::new(#name, ParamDefault::exists(#is_option)),
268			})272			})
269		}273		}
270		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,274		ArgInfo::Context | ArgInfo::Location | ArgInfo::This => None,
375		const _: () = {379		const _: () = {
376			use ::jrsonnet_evaluator::{380			use ::jrsonnet_evaluator::{
377				State, Val,381				State, Val,
378				function::{builtin::{Builtin, StaticBuiltin, BuiltinParam, ParamName}, CallLocation, ArgsLike, parse::parse_builtin_call},382				function::{builtin::{Builtin, StaticBuiltin, BuiltinParam, ParamName, ParamDefault}, CallLocation, ArgsLike, parse::parse_builtin_call},
379				Result, Context, typed::Typed,383				Result, Context, typed::Typed,
380				parser::ExprLocation,384				parser::ExprLocation,
381			};385			};