git.delta.rocks / jrsonnet / refs/commits / 4ec63264e784

1use gcmodule::Cc;1use gcmodule::Cc;
2use jrsonnet_evaluator::{2use jrsonnet_evaluator::{
3	error::{Error, LocError},3	error::{Error, LocError},
4	function::BuiltinParam,
4	gc::TraceBox,5	gc::TraceBox,
5	native::{NativeCallback, NativeCallbackHandler},6	native::{NativeCallback, NativeCallbackHandler},
6	EvaluationState, IStr, Val,7	EvaluationState, IStr, Val,
7};8};
8use jrsonnet_parser::{Param, ParamsDesc};
9use std::{9use std::{
10	convert::TryFrom,10	convert::TryFrom,
11	ffi::{c_void, CStr},11	ffi::{c_void, CStr},
28	cb: JsonnetNativeCallback,28	cb: JsonnetNativeCallback,
29}29}
30impl NativeCallbackHandler for JsonnetNativeCallbackHandler {30impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
31	fn call(&self, _from: Rc<Path>, args: &[Val]) -> Result<Val, LocError> {31	fn call(&self, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {
32		let mut n_args = Vec::new();32		let mut n_args = Vec::new();
33		for a in args {33		for a in args {
34			n_args.push(Some(Box::new(a.clone())));34			n_args.push(Some(Box::new(a.clone())));
68			break;68			break;
69		}69		}
70		let param = CStr::from_ptr(*raw_params).to_str().expect("not utf8");70		let param = CStr::from_ptr(*raw_params).to_str().expect("not utf8");
71		params.push(Param(param.into(), None));71		params.push(BuiltinParam {
72			name: param.into(),
73			has_default: false,
74		});
72		raw_params = raw_params.offset(1);75		raw_params = raw_params.offset(1);
73	}76	}
74	let params = ParamsDesc(Rc::new(params));
7577
76	vm.add_native(78	vm.add_native(
77		name,79		name,
80		#[allow(deprecated)]
78		Cc::new(NativeCallback::new(81		Cc::new(TraceBox(Box::new(NativeCallback::new(
79			params,82			params,
80			TraceBox(Box::new(JsonnetNativeCallbackHandler { ctx, cb })),83			TraceBox(Box::new(JsonnetNativeCallbackHandler { ctx, cb })),
81		)),84		)))),
82	)85	)
83}86}
8487

11};11};
12use crate::{Either, ObjValue};12use crate::{Either, ObjValue};
13use format::{format_arr, format_obj};13use format::{format_arr, format_obj};
14use gcmodule::Cc;
15use jrsonnet_interner::IStr;14use jrsonnet_interner::IStr;
16use jrsonnet_parser::ExprLocation;15use jrsonnet_parser::ExprLocation;
17use serde::Deserialize;16use serde::Deserialize;
142}141}
143142
144#[jrsonnet_macros::builtin]143#[jrsonnet_macros::builtin]
145fn builtin_length(x: Either![IStr, VecVal, ObjValue, Cc<FuncVal>]) -> Result<usize> {144fn builtin_length(x: Either![IStr, VecVal, ObjValue, FuncVal]) -> Result<usize> {
146	use Either4::*;145	use Either4::*;
147	Ok(match x {146	Ok(match x {
148		A(x) => x.chars().count(),147		A(x) => x.chars().count(),
162}161}
163162
164#[jrsonnet_macros::builtin]163#[jrsonnet_macros::builtin]
165fn builtin_make_array(sz: usize, func: Cc<FuncVal>) -> Result<VecVal> {164fn builtin_make_array(sz: usize, func: FuncVal) -> Result<VecVal> {
166	let mut out = Vec::with_capacity(sz);165	let mut out = Vec::with_capacity(sz);
167	for i in 0..sz {166	for i in 0..sz {
168		out.push(func.evaluate_simple(&[i as f64].as_slice())?)167		out.push(func.evaluate_simple(&[i as f64].as_slice())?)
345}344}
346345
347#[jrsonnet_macros::builtin]346#[jrsonnet_macros::builtin]
348fn builtin_native(name: IStr) -> Result<Cc<FuncVal>> {347fn builtin_native(name: IStr) -> Result<FuncVal> {
349	Ok(with_state(|s| s.settings().ext_natives.get(&name).cloned())348	Ok(with_state(|s| s.settings().ext_natives.get(&name).cloned())
350		.map(|v| Cc::new(FuncVal::NativeExt(name.clone(), v)))349		.map(|v| FuncVal::Builtin(v.clone()))
351		.ok_or(UndefinedExternalFunction(name))?)350		.ok_or(UndefinedExternalFunction(name))?)
352}351}
353352
354#[jrsonnet_macros::builtin]353#[jrsonnet_macros::builtin]
355fn builtin_filter(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {354fn builtin_filter(func: FuncVal, arr: ArrValue) -> Result<ArrValue> {
356	arr.filter(|val| bool::try_from(func.evaluate_simple(&[Any(val.clone())].as_slice())?))355	arr.filter(|val| bool::try_from(func.evaluate_simple(&[Any(val.clone())].as_slice())?))
357}356}
358357
359#[jrsonnet_macros::builtin]358#[jrsonnet_macros::builtin]
360fn builtin_map(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {359fn builtin_map(func: FuncVal, arr: ArrValue) -> Result<ArrValue> {
361	arr.map(|val| func.evaluate_simple(&[Any(val)].as_slice()))360	arr.map(|val| func.evaluate_simple(&[Any(val)].as_slice()))
362}361}
363362
364#[jrsonnet_macros::builtin]363#[jrsonnet_macros::builtin]
365fn builtin_flatmap(func: Cc<FuncVal>, arr: IndexableVal) -> Result<IndexableVal> {364fn builtin_flatmap(func: FuncVal, arr: IndexableVal) -> Result<IndexableVal> {
366	match arr {365	match arr {
367		IndexableVal::Str(s) => {366		IndexableVal::Str(s) => {
368			let mut out = String::new();367			let mut out = String::new();
397}396}
398397
399#[jrsonnet_macros::builtin]398#[jrsonnet_macros::builtin]
400fn builtin_foldl(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {399fn builtin_foldl(func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {
401	let mut acc = init.0;400	let mut acc = init.0;
402	for i in arr.iter() {401	for i in arr.iter() {
403		acc = func.evaluate_simple(&[Any(acc), Any(i?)].as_slice())?;402		acc = func.evaluate_simple(&[Any(acc), Any(i?)].as_slice())?;
406}405}
407406
408#[jrsonnet_macros::builtin]407#[jrsonnet_macros::builtin]
409fn builtin_foldr(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {408fn builtin_foldr(func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {
410	let mut acc = init.0;409	let mut acc = init.0;
411	for i in arr.iter().rev() {410	for i in arr.iter().rev() {
412		acc = func.evaluate_simple(&[Any(i?), Any(acc)].as_slice())?;411		acc = func.evaluate_simple(&[Any(i?), Any(acc)].as_slice())?;
416415
417#[jrsonnet_macros::builtin]416#[jrsonnet_macros::builtin]
418#[allow(non_snake_case)]417#[allow(non_snake_case)]
419fn builtin_sort(arr: ArrValue, keyF: Option<Cc<FuncVal>>) -> Result<ArrValue> {418fn builtin_sort(arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
420	if arr.len() <= 1 {419	if arr.len() <= 1 {
421		return Ok(arr);420		return Ok(arr);
422	}421	}
423	Ok(ArrValue::Eager(sort::sort(422	Ok(ArrValue::Eager(sort::sort(
424		arr.evaluated()?,423		arr.evaluated()?,
425		keyF.as_deref(),424		keyF.as_ref(),
426	)?))425	)?))
427}426}
428427

177}177}
178178
179pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {179pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
180	Val::Func(Cc::new(FuncVal::Normal(FuncDesc {180	Val::Func(FuncVal::Normal(Cc::new(FuncDesc {
181		name,181		name,
182		ctx,182		ctx,
183		params,183		params,
630		Function(params, body) => {630		Function(params, body) => {
631			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())631			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())
632		}632		}
633		Intrinsic(name) => Val::Func(Cc::new(FuncVal::StaticBuiltin(633		Intrinsic(name) => Val::Func(FuncVal::StaticBuiltin(
634			BUILTINS634			BUILTINS
635				.with(|b| b.get(name).copied())635				.with(|b| b.get(name).copied())
636				.ok_or_else(|| IntrinsicNotFound(name.clone()))?,636				.ok_or_else(|| IntrinsicNotFound(name.clone()))?,
637		))),637		)),
638		AssertExpr(assert, returned) => {638		AssertExpr(assert, returned) => {
639			evaluate_assert(context.clone(), assert)?;639			evaluate_assert(context.clone(), assert)?;
640			evaluate(context, returned)?640			evaluate(context, returned)?

371371
372type BuiltinParamName = Cow<'static, str>;372type BuiltinParamName = Cow<'static, str>;
373373
374#[derive(Clone)]374#[derive(Clone, Trace)]
375pub struct BuiltinParam {375pub struct BuiltinParam {
376	pub name: BuiltinParamName,376	pub name: BuiltinParamName,
377	pub has_default: bool,377	pub has_default: bool,

13mod dynamic;13mod dynamic;
14pub mod error;14pub mod error;
15mod evaluate;15mod evaluate;
16mod function;16pub mod function;
17mod import;17mod import;
18mod integrations;18mod integrations;
19mod map;19mod map;
27pub use dynamic::*;27pub use dynamic::*;
28use error::{Error::*, LocError, Result, StackTraceElement};28use error::{Error::*, LocError, Result, StackTraceElement};
29pub use evaluate::*;29pub use evaluate::*;
30pub use function::parse_function_call;
31use function::TlaArg;30use function::{Builtin, TlaArg};
32use gc::{GcHashMap, TraceBox};31use gc::{GcHashMap, TraceBox};
33use gcmodule::{Cc, Trace};32use gcmodule::{Cc, Trace};
34pub use import::*;33pub use import::*;
35pub use jrsonnet_interner::IStr;34pub use jrsonnet_interner::IStr;
36use jrsonnet_parser::*;35use jrsonnet_parser::*;
37use native::NativeCallback;
38pub use obj::*;36pub use obj::*;
39use std::{37use std::{
40	cell::{Ref, RefCell, RefMut},38	cell::{Ref, RefCell, RefMut},
79	/// Used for s`td.extVar`77	/// Used for s`td.extVar`
80	pub ext_vars: HashMap<IStr, Val>,78	pub ext_vars: HashMap<IStr, Val>,
81	/// Used for ext.native79	/// Used for ext.native
82	pub ext_natives: HashMap<IStr, Cc<NativeCallback>>,80	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,
83	/// TLA vars81	/// TLA vars
84	pub tla_vars: HashMap<IStr, TlaArg>,82	pub tla_vars: HashMap<IStr, TlaArg>,
85	/// Global variables are inserted in default context83	/// Global variables are inserted in default context
614		self.settings_mut().import_resolver = resolver;612		self.settings_mut().import_resolver = resolver;
615	}613	}
616614
617	pub fn add_native(&self, name: IStr, cb: Cc<NativeCallback>) {615	pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {
618		self.settings_mut().ext_natives.insert(name, cb);616		self.settings_mut().ext_natives.insert(name, cb);
619	}617	}
620618
657pub mod tests {655pub mod tests {
658	use super::Val;656	use super::Val;
659	use crate::{657	use crate::{
660		error::Error::*, gc::TraceBox, native::NativeCallbackHandler, primitive_equals,658		error::Error::*, function::BuiltinParam, gc::TraceBox, native::NativeCallbackHandler,
661		EvaluationState,659		primitive_equals, EvaluationState,
662	};660	};
663	use gcmodule::{Cc, Trace};661	use gcmodule::{Cc, Trace};
1096		#[derive(Trace)]1094		#[derive(Trace)]
1097		struct NativeAdd;1095		struct NativeAdd;
1098		impl NativeCallbackHandler for NativeAdd {1096		impl NativeCallbackHandler for NativeAdd {
1099			fn call(&self, from: Rc<Path>, args: &[Val]) -> crate::error::Result<Val> {1097			fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {
1100				assert_eq!(&from as &Path, &PathBuf::from("native_caller.jsonnet"));1098				assert_eq!(
1099					&from.unwrap() as &Path,
1100					&PathBuf::from("native_caller.jsonnet")
1101				);
1101				match (&args[0], &args[1]) {1102				match (&args[0], &args[1]) {
1106		}1107		}
1107		evaluator.settings_mut().ext_natives.insert(1108		evaluator.settings_mut().ext_natives.insert(
1108			"native_add".into(),1109			"native_add".into(),
1110			#[allow(deprecated)]
1109			Cc::new(NativeCallback::new(1111			Cc::new(TraceBox(Box::new(NativeCallback::new(
1110				ParamsDesc(Rc::new(vec![1112				vec![
1113					BuiltinParam {
1111					Param("a".into(), None),1114						name: "a".into(),
1115						has_default: false,
1116					},
1117					BuiltinParam {
1112					Param("b".into(), None),1118						name: "b".into(),
1119						has_default: false,
1120					},
1113				])),1121				],
1114				TraceBox(Box::new(NativeAdd)),1122				TraceBox(Box::new(NativeAdd)),
1115			)),1123			)))),
1116		);1124		);
1117		evaluator.evaluate_snippet_raw(1125		evaluator.evaluate_snippet_raw(
1118			PathBuf::from("native_caller.jsonnet").into(),1126			PathBuf::from("native_caller.jsonnet").into(),

1#![allow(clippy::type_complexity)]1#![allow(clippy::type_complexity)]
22
3use crate::function::{parse_builtin_call, ArgsLike, Builtin, BuiltinParam};
3use crate::gc::TraceBox;4use crate::gc::TraceBox;
5use crate::Context;
4use crate::{error::Result, Val};6use crate::{error::Result, Val};
5use gcmodule::Trace;7use gcmodule::Trace;
6use jrsonnet_parser::ParamsDesc;8use jrsonnet_parser::ExprLocation;
7use std::fmt::Debug;
8use std::path::Path;9use std::path::Path;
9use std::rc::Rc;10use std::rc::Rc;
1011
11#[deprecated(note = "Use builtins instead")]12#[derive(Trace)]
12pub trait NativeCallbackHandler: Trace {13pub struct NativeCallback {
13	fn call(&self, from: Rc<Path>, args: &[Val]) -> Result<Val>;14	pub(crate) params: Vec<BuiltinParam>,
14}15	handler: TraceBox<dyn NativeCallbackHandler>,
1516}
17impl NativeCallback {
16#[derive(Trace)]18	#[deprecated = "prefer using builtins directly, use this interface only for bindings"]
17pub struct NativeCallback {19	pub fn new(params: Vec<BuiltinParam>, handler: TraceBox<dyn NativeCallbackHandler>) -> Self {
18	pub params: ParamsDesc,20		Self { params, handler }
19	handler: TraceBox<dyn NativeCallbackHandler>,21	}
20}22}
23
21impl NativeCallback {24impl Builtin for NativeCallback {
25	fn name(&self) -> &str {
26		// TODO: standard natives gets their names from definition
27		// But builitins should already have them
28		"<native>"
29	}
30
22	pub fn new(params: ParamsDesc, handler: TraceBox<dyn NativeCallbackHandler>) -> Self {31	fn params(&self) -> &[BuiltinParam] {
23		Self { params, handler }32		&self.params
24	}33	}
34
25	pub fn call(&self, caller: Rc<Path>, args: &[Val]) -> Result<Val> {35	fn call(
36		&self,
37		context: Context,
38		loc: Option<&ExprLocation>,
39		args: &dyn ArgsLike,
40	) -> Result<Val> {
41		let args = parse_builtin_call(context, &self.params, args, true)?;
42		let mut out_args = Vec::with_capacity(self.params.len());
43		for p in self.params.iter() {
44			out_args.push(args[&p.name].evaluate()?);
45		}
26		self.handler.call(caller, args)46		self.handler.call(loc.map(|l| l.0.clone()), &out_args)
27	}47	}
28}48}
49
29impl Debug for NativeCallback {50pub trait NativeCallbackHandler: Trace {
30	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {51	fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> Result<Val>;
31		f.debug_struct("NativeCallback").finish()
32	}
33}52}
3453

1use std::convert::{TryFrom, TryInto};1use std::convert::{TryFrom, TryInto};
22
3use gcmodule::Cc;
4use jrsonnet_interner::IStr;3use jrsonnet_interner::IStr;
5use jrsonnet_types::{ComplexValType, ValType};4use jrsonnet_types::{ComplexValType, ValType};
65
400	}399	}
401}400}
402401
403impl Typed for Cc<FuncVal> {402impl Typed for FuncVal {
404	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);403	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);
405}404}
406impl TryFrom<Val> for Cc<FuncVal> {405impl TryFrom<Val> for FuncVal {
407	type Error = LocError;406	type Error = LocError;
408407
409	fn try_from(value: Val) -> Result<Self> {408	fn try_from(value: Val) -> Result<Self> {
414		}413		}
415	}414	}
416}415}
417impl TryFrom<Cc<FuncVal>> for Val {416impl TryFrom<FuncVal> for Val {
418	type Error = LocError;417	type Error = LocError;
419418
420	fn try_from(value: Cc<FuncVal>) -> Result<Self> {419	fn try_from(value: FuncVal) -> Result<Self> {
421		Ok(Self::Func(value))420		Ok(Self::Func(value))
422	}421	}
423}422}

7	evaluate,7	evaluate,
8	function::{parse_function_call, ArgsLike, Builtin, StaticBuiltin},8	function::{parse_function_call, ArgsLike, Builtin, StaticBuiltin},
9	gc::TraceBox,9	gc::TraceBox,
10	native::NativeCallback,
11	throw, Context, ObjValue, Result,10	throw, Context, ObjValue, Result,
12};11};
13use gcmodule::{Cc, Trace};12use gcmodule::{Cc, Trace};
86	pub body: LocExpr,85	pub body: LocExpr,
87}86}
8887
89#[derive(Trace)]88#[derive(Trace, Clone)]
90pub enum FuncVal {89pub enum FuncVal {
91	/// Plain function implemented in jsonnet90	/// Plain function implemented in jsonnet
92	Normal(FuncDesc),91	Normal(Cc<FuncDesc>),
93	/// Standard library function92	/// Standard library function
94	StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),93	StaticBuiltin(#[skip_trace] &'static dyn StaticBuiltin),
9594
96	Builtin(TraceBox<dyn Builtin>),95	Builtin(Cc<TraceBox<dyn Builtin>>),
97	/// Library functions implemented in native
98	NativeExt(IStr, Cc<NativeCallback>),
99}96}
10097
101impl Debug for FuncVal {98impl Debug for FuncVal {
104			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),101			Self::Normal(arg0) => f.debug_tuple("Normal").field(arg0).finish(),
105			Self::StaticBuiltin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),102			Self::StaticBuiltin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),
106			Self::Builtin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),103			Self::Builtin(arg0) => f.debug_tuple("Intrinsic").field(&arg0.name()).finish(),
107			Self::NativeExt(arg0, arg1) => {
108				f.debug_tuple("NativeExt").field(arg0).field(arg1).finish()
109			}
110		}104		}
111	}105	}
112}106}
116		match (self, other) {110		match (self, other) {
117			(Self::Normal(a), Self::Normal(b)) => a == b,111			(Self::Normal(a), Self::Normal(b)) => a == b,
118			(Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),112			(Self::StaticBuiltin(an), Self::StaticBuiltin(bn)) => std::ptr::eq(*an, *bn),
119			(Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,
120			(..) => false,113			(..) => false,
121		}114		}
122	}115	}
127			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),120			Self::Normal(n) => n.params.iter().filter(|p| p.1.is_none()).count(),
128			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),121			Self::StaticBuiltin(i) => i.params().iter().filter(|p| !p.has_default).count(),
129			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),122			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),
130			Self::NativeExt(_, n) => n.params.iter().filter(|p| p.1.is_none()).count(),
131		}123		}
132	}124	}
133	pub fn name(&self) -> IStr {125	pub fn name(&self) -> IStr {
134		match self {126		match self {
135			Self::Normal(normal) => normal.name.clone(),127			Self::Normal(normal) => normal.name.clone(),
136			Self::StaticBuiltin(builtin) => builtin.name().into(),128			Self::StaticBuiltin(builtin) => builtin.name().into(),
137			Self::Builtin(builtin) => builtin.name().into(),129			Self::Builtin(builtin) => builtin.name().into(),
138			Self::NativeExt(n, _) => format!("native.{}", n).into(),
139		}130		}
140	}131	}
141	pub fn evaluate(132	pub fn evaluate(
158			}149			}
159			Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),150			Self::StaticBuiltin(name) => name.call(call_ctx, loc, args),
160			Self::Builtin(b) => b.call(call_ctx, loc, args),151			Self::Builtin(b) => b.call(call_ctx, loc, args),
161			Self::NativeExt(_name, handler) => {
162				let args =
163					parse_function_call(call_ctx, Context::new(), &handler.params, args, true)?;
164				let mut out_args = Vec::with_capacity(handler.params.len());
165				for p in handler.params.0.iter() {
166					out_args.push(args.binding(p.0.clone())?.evaluate()?);
167				}
168				Ok(handler.call(loc.expect("todo").0.clone(), &out_args)?)
169			}
170		}152		}
171	}153	}
172	pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {154	pub fn evaluate_simple(&self, args: &dyn ArgsLike) -> Result<Val> {
352	Num(f64),334	Num(f64),
353	Arr(ArrValue),335	Arr(ArrValue),
354	Obj(ObjValue),336	Obj(ObjValue),
355	Func(Cc<FuncVal>),337	Func(FuncVal),
356}338}
357339
358impl Val {340impl Val {