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

9393
94/// # Safety94/// # Safety
95///95///
96/// Caller should pass correct callback function96/// It should be safe to call `cb` using valid values with passed `ctx`
97#[no_mangle]97#[no_mangle]
98pub unsafe extern "C" fn jsonnet_import_callback(98pub unsafe extern "C" fn jsonnet_import_callback(
99	vm: &State,99	vm: &State,
109109
110/// # Safety110/// # Safety
111///111///
112/// Caller should pass correct path: it should contain correct utf-8, and be \0-terminated112/// `path` should be a NUL-terminated string
113#[no_mangle]113#[no_mangle]
114pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, v: *const c_char) {114pub unsafe extern "C" fn jsonnet_jpath_add(vm: &State, path: *const c_char) {
115	let cstr = CStr::from_ptr(v);115	let cstr = CStr::from_ptr(path);
116	let path = PathBuf::from(cstr.to_str().unwrap());116	let path = PathBuf::from(cstr.to_str().unwrap());
117	let any_resolver = vm.import_resolver();117	let any_resolver = vm.import_resolver();
118	let resolver = any_resolver118	let resolver = any_resolver

41		let str = OsStr::from_bytes(input.to_bytes());41		let str = OsStr::from_bytes(input.to_bytes());
42		Cow::Borrowed(Path::new(str))42		Cow::Borrowed(Path::new(str))
43	}43	}
44	#[cfg(target_family = "windows")]44	#[cfg(not(target_family = "unix"))]
45	{45	{
46		use std::os::windows::ffi::OsStringExt;
47		let str = input.to_str().expect("input is not utf8");46		let string = input.to_str().expect("bad utf-8");
48		let wide = str.encode_utf16().collect::<Vec<_>>();
49		let wide = OsString::from_wide(&wide);
50		Cow::Owned(PathBuf::new(wide))47		Cow::Borrowed(string.as_ref())
51	}48	}
52	#[cfg(not(any(target_family = "unix", target_family = "windows")))]
53	{
54		compile_error!("unsupported os")
55	}
56}49}
5750
58unsafe fn unparse_path(input: &Path) -> Cow<CStr> {51unsafe fn unparse_path(input: &Path) -> Cow<CStr> {
62		let str = CString::new(input.as_os_str().as_bytes()).expect("input has zero byte in it");55		let str = CString::new(input.as_os_str().as_bytes()).expect("input has zero byte in it");
63		Cow::Owned(str)56		Cow::Owned(str)
64	}57	}
65	#[cfg(not(any(target_family = "unix", target_family = "windows")))]58	#[cfg(not(target_family = "unix"))]
66	{59	{
60		let str = input.as_os_str().to_str().expect("bad utf-8");
67		compile_error!("unsupported os")61		let cstr = CString::new(str).expect("input has NUL inside");
62		Cow::Owned(cstr)
68	}63	}
69}64}
7065
169///164///
170/// # Safety165/// # Safety
171///166///
172/// `filename` should be a \0-terminated string167/// `filename` should be a NUL-terminated string
173#[no_mangle]168#[no_mangle]
174pub unsafe extern "C" fn jsonnet_evaluate_file(169pub unsafe extern "C" fn jsonnet_evaluate_file(
175	vm: &State,170	vm: &State,
200///195///
201/// # Safety196/// # Safety
202///197///
203/// `filename`, `snippet` should be a \0-terminated strings198/// `filename`, `snippet` should be a NUL-terminated strings
204#[no_mangle]199#[no_mangle]
205pub unsafe extern "C" fn jsonnet_evaluate_snippet(200pub unsafe extern "C" fn jsonnet_evaluate_snippet(
206	vm: &State,201	vm: &State,

65/// # Safety65/// # Safety
66///66///
67/// `vm` should be a vm allocated by `jsonnet_make`67/// `vm` should be a vm allocated by `jsonnet_make`
68/// `name` should be a NUL-terminated string
68/// `cb` should be a correct function pointer69/// `cb` should be a function pointer
69/// `raw_params` should point to a NULL-terminated string array70/// `raw_params` should point to a NULL-terminated array of NUL-terminated strings
70/// `name`, `raw_params` elements should be a \0-terminated strings
71#[no_mangle]71#[no_mangle]
72pub unsafe extern "C" fn jsonnet_native_callback(72pub unsafe extern "C" fn jsonnet_native_callback(
73	vm: &State,73	vm: &State,

12///12///
13/// # Safety13/// # Safety
14///14///
15/// `v` should be a \0-terminated string15/// `v` should be a NUL-terminated string
16#[no_mangle]16#[no_mangle]
17pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &State, val: *const c_char) -> *mut Val {17pub unsafe extern "C" fn jsonnet_json_make_string(_vm: &State, val: *const c_char) -> *mut Val {
18	let val = CStr::from_ptr(val);18	let val = CStr::from_ptr(val);

11///11///
12/// # Safety12/// # Safety
13///13///
14/// `arr` should be correct pointer to array value allocated by make_array, or returned by other library call14/// `arr` should be a pointer to array value allocated by make_array, or returned by other library call
15/// `val` should be correct pointer to value allocated using this library15/// `val` should be a pointer to value allocated using this library
16#[no_mangle]16#[no_mangle]
17pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &State, arr: &mut Val, val: &Val) {17pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &State, arr: &mut Val, val: &Val) {
18	match arr {18	match arr {
35///35///
36/// # Safety36/// # Safety
37///37///
38/// `obj` should be a valid pointer to object value allocated by `make_object`, or returned by other library call38/// `obj` should be a pointer to object value allocated by `make_object`, or returned by other library call
39/// `name` should be \0-terminated string39/// `name` should be NUL-terminated string
40#[no_mangle]40#[no_mangle]
41pub unsafe extern "C" fn jsonnet_json_object_append(41pub unsafe extern "C" fn jsonnet_json_object_append(
42	_vm: &State,42	_vm: &State,

44
5use jrsonnet_evaluator::State;5use jrsonnet_evaluator::State;
66
7/// Bind a Jsonnet external var to the given string.7/// Binds a Jsonnet external variable to the given string.
8///8///
9/// Argument values are copied so memory should be managed by caller.9/// Argument values are copied so memory should be managed by the caller.
10///10///
11/// # Safety11/// # Safety
12///12///
13/// Caller should pass correct pointers as `name` and `code`, they need to be \0-terminated strings13/// `name`, `code` should be a NUL-terminated strings
14#[no_mangle]14#[no_mangle]
15pub unsafe extern "C" fn jsonnet_ext_var(vm: &State, name: *const c_char, value: *const c_char) {15pub unsafe extern "C" fn jsonnet_ext_var(vm: &State, name: *const c_char, value: *const c_char) {
16	let name = CStr::from_ptr(name);16	let name = CStr::from_ptr(name);
27		)27		)
28}28}
2929
30/// Bind a Jsonnet external var to the given code.30/// Binds a Jsonnet external variable to the given code.
31///31///
32/// Argument values are copied so memory should be managed by caller.32/// Argument values are copied so memory should be managed by the caller.
33///33///
34/// # Safety34/// # Safety
35///35///
36/// Caller should pass correct pointers as `name` and `code`, they need to be \0-terminated strings36/// `name`, `code` should be a NUL-terminated strings
37#[no_mangle]37#[no_mangle]
38pub unsafe extern "C" fn jsonnet_ext_code(vm: &State, name: *const c_char, code: *const c_char) {38pub unsafe extern "C" fn jsonnet_ext_code(vm: &State, name: *const c_char, code: *const c_char) {
39	let name = CStr::from_ptr(name);39	let name = CStr::from_ptr(name);
51		.expect("can't parse ext code")51		.expect("can't parse ext code")
52}52}
5353
54/// Bind a string top-level argument for a top-level parameter.54/// Binds a top-level string argument for a top-level parameter.
55///55///
56/// Argument values are copied so memory should be managed by caller.56/// Argument values are copied so memory should be managed by the caller.
57///57///
58/// # Safety58/// # Safety
59///59///
60/// Caller should pass correct pointers as `name` and `value`, they need to be \0-terminated strings60/// `name`, `value` should be a NUL-terminated strings
61#[no_mangle]61#[no_mangle]
62pub unsafe extern "C" fn jsonnet_tla_var(vm: &State, name: *const c_char, value: *const c_char) {62pub unsafe extern "C" fn jsonnet_tla_var(vm: &State, name: *const c_char, value: *const c_char) {
63	let name = CStr::from_ptr(name);63	let name = CStr::from_ptr(name);
68	)68	)
69}69}
7070
71/// Bind a code top-level argument for a top-level parameter.71/// Binds a top-level code argument for a top-level parameter.
72///72///
73/// Argument values are copied so memory should be managed by caller.73/// Argument values are copied so memory should be managed by the caller.
74///74///
75/// # Safety75/// # Safety
76///76///
77/// Caller should pass correct pointers as `name` and `code`, they need to be \0-terminated strings77/// `name`, `code` should be a NUL-terminated strings
78#[no_mangle]78#[no_mangle]
79pub unsafe extern "C" fn jsonnet_tla_code(vm: &State, name: *const c_char, code: *const c_char) {79pub unsafe extern "C" fn jsonnet_tla_code(vm: &State, name: *const c_char, code: *const c_char) {
80	let name = CStr::from_ptr(name);80	let name = CStr::from_ptr(name);

20	}20	}
21}21}
2222
23/// Context keeps information about current lexical code location
24///
25/// This information includes local variables, top-level object (`$`), current object (`this`), and super object (`super`)
23#[derive(Debug, Clone, Trace)]26#[derive(Debug, Clone, Trace)]
24pub struct Context(Cc<ContextInternals>);27pub struct Context(Cc<ContextInternals>);
25impl Context {28impl Context {
160			extend: Some(parent),163			extend: Some(parent),
161		}164		}
162	}165	}
166	/// # Panics
167	/// If `name` is already bound
163	pub fn bind(&mut self, name: IStr, value: Thunk<Val>) -> &mut Self {168	pub fn bind(&mut self, name: IStr, value: Thunk<Val>) -> &mut Self {
164		self.bindings.insert(name, value);169		let old = self.bindings.insert(name, value);
170		assert!(old.is_none(), "variable bound twice in single context call");
165		self171		self
166	}172	}
167	pub fn build(self) -> Context {173	pub fn build(self) -> Context {

6767
68type FunctionSignature = Vec<(Option<IStr>, bool)>;68type FunctionSignature = Vec<(Option<IStr>, bool)>;
6969
70/// Possible errors
71#[allow(missing_docs)]
70#[derive(Error, Debug, Clone, Trace)]72#[derive(Error, Debug, Clone, Trace)]
73#[non_exhaustive]
71pub enum Error {74pub enum Error {
72	#[error("intrinsic not found: {0}")]75	#[error("intrinsic not found: {0}")]
73	IntrinsicNotFound(IStr),76	IntrinsicNotFound(IStr),
217	}220	}
218}221}
219222
223/// Single stack trace frame
220#[derive(Clone, Debug, Trace)]224#[derive(Clone, Debug, Trace)]
221pub struct StackTraceElement {225pub struct StackTraceElement {
226	/// Source of this frame
227	/// Some frames only act as description, without attached source
222	pub location: Option<ExprLocation>,228	pub location: Option<ExprLocation>,
229	/// Frame description
223	pub desc: String,230	pub desc: String,
224}231}
225#[derive(Debug, Clone, Trace)]232#[derive(Debug, Clone, Trace)]

269		}269		}
270	}270	}
271	let this = builder.build();271	let this = builder.build();
272	let _ctx = ctx272	fctx.fill(ctx.extend(GcHashMap::new(), None, None, Some(this.clone())));
273		.extend(GcHashMap::new(), None, None, Some(this.clone()))
274		.into_future(fctx);
275	Ok(this)273	Ok(this)
276}274}
277275
356	ctx: Context,354	ctx: Context,
357	value: &LocExpr,355	value: &LocExpr,
358	args: &ArgsDesc,356	args: &ArgsDesc,
359	loc: CallLocation,357	loc: CallLocation<'_>,
360	tailstrict: bool,358	tailstrict: bool,
361) -> Result<Val> {359) -> Result<Val> {
362	let value = evaluate(s.clone(), ctx.clone(), value)?;360	let value = evaluate(s.clone(), ctx.clone(), value)?;
602		}600		}
603		Slice(value, desc) => {601		Slice(value, desc) => {
604			fn parse_idx<T: Typed>(602			fn parse_idx<T: Typed>(
605				loc: CallLocation,603				loc: CallLocation<'_>,
606				s: State,604				s: State,
607				ctx: &Context,605				ctx: &Context,
608				expr: &Option<LocExpr>,606				expr: &Option<LocExpr>,

28		&self,
29		s: State,
30		ctx: Context,
31		loc: CallLocation<'_>,
32		args: &dyn ArgsLike,
33	) -> Result<Val>;
28}34}
80		&self,
81		s: State,
82		ctx: Context,
83		_loc: CallLocation<'_>,
84		args: &dyn ArgsLike,
85	) -> Result<Val> {
74		let args = parse_builtin_call(s.clone(), ctx, &self.params, args, true)?;86		let args = parse_builtin_call(s.clone(), ctx, &self.params, args, true)?;

18pub mod native;18pub mod native;
19pub mod parse;19pub mod parse;
2020
21/// Function callsite location.
22/// Either from other jsonnet code, specified by expression location, or from native (without location).
21#[derive(Clone, Copy)]23#[derive(Clone, Copy)]
22pub struct CallLocation<'l>(pub Option<&'l ExprLocation>);24pub struct CallLocation<'l>(pub Option<&'l ExprLocation>);
23impl<'l> CallLocation<'l> {25impl<'l> CallLocation<'l> {
26	/// Construct new location for calls coming from specified jsonnet expression location.
24	pub const fn new(loc: &'l ExprLocation) -> Self {27	pub const fn new(loc: &'l ExprLocation) -> Self {
25		Self(Some(loc))28		Self(Some(loc))
26	}29	}
27}30}
28impl CallLocation<'static> {31impl CallLocation<'static> {
32	/// Construct new location for calls coming from native code.
29	pub const fn native() -> Self {33	pub const fn native() -> Self {
30		Self(None)34		Self(None)
31	}35	}
32}36}
3337
34/// Function implemented in jsonnet38/// Represents Jsonnet function defined in code.
35#[derive(Debug, PartialEq, Trace)]39#[derive(Debug, PartialEq, Trace)]
36pub struct FuncDesc {40pub struct FuncDesc {
37	/// In expressions like41	/// # Example
42	///
43	/// In expressions like this, deducted to `a`, unspecified otherwise.
38	/// ```jsonnet44	/// ```jsonnet
39	/// local a = function() ...45	/// local a = function() ...
40	/// local a() ...46	/// local a() ...
41	/// { a: function() ... }47	/// { a: function() ... }
42	/// { a() = ... }48	/// { a() = ... }
43	/// ```49	/// ```
44	///
45	/// Deducted to `a`, unspecified otherwise
46	pub name: IStr,50	pub name: IStr,
47	/// Context, in which this function was evaluated51	/// Context, in which this function was evaluated.
48	///52	///
53	/// # Example
49	/// I.e in54	/// In
50	/// ```jsonnet55	/// ```jsonnet
51	/// local a = 2;56	/// local a = 2;
52	/// function() ...57	/// function() ...
53	/// ```58	/// ```
54	/// context will contain `a`59	/// context will contain `a`.
55	pub ctx: Context,60	pub ctx: Context,
5661
62	/// Function parameter definition
57	pub params: ParamsDesc,63	pub params: ParamsDesc,
64	/// Function body
58	pub body: LocExpr,65	pub body: LocExpr,
59}66}
60impl FuncDesc {67impl FuncDesc {
82	}89	}
83}90}
8491
85/// Any possible function value, including plain functions and user-provided builtins92/// Represents a Jsonnet function value, including plain functions and user-provided builtins.
86#[allow(clippy::module_name_repetitions)]93#[allow(clippy::module_name_repetitions)]
87#[derive(Trace, Clone)]94#[derive(Trace, Clone)]
88pub enum FuncVal {95pub enum FuncVal {
89	/// std.id96	/// Identity function, kept this way for comparsions.
90	Id,97	Id,
91	/// Plain function implemented in jsonnet98	/// Plain function implemented in jsonnet.
92	Normal(Cc<FuncDesc>),99	Normal(Cc<FuncDesc>),
93	/// Standard library function100	/// Standard library function.
94	StaticBuiltin(#[trace(skip)] &'static dyn StaticBuiltin),101	StaticBuiltin(#[trace(skip)] &'static dyn StaticBuiltin),
95	/// User-provided function102	/// User-provided function.
96	Builtin(Cc<TraceBox<dyn Builtin>>),103	Builtin(Cc<TraceBox<dyn Builtin>>),
97}104}
98105
110}117}
111118
112impl FuncVal {119impl FuncVal {
113	pub fn into_native<D: NativeDesc>(self) -> D::Value {120	/// Amount of non-default required arguments
114		D::into_native(self)
115	}
116	pub fn params_len(&self) -> usize {121	pub fn params_len(&self) -> usize {
117		match self {122		match self {
118			Self::Id => 1,123			Self::Id => 1,
121			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),126			Self::Builtin(i) => i.params().iter().filter(|p| !p.has_default).count(),
122		}127		}
123	}128	}
129	/// Function name, as defined in code.
124	pub fn name(&self) -> IStr {130	pub fn name(&self) -> IStr {
125		match self {131		match self {
126			Self::Id => "id".into(),132			Self::Id => "id".into(),
129			Self::Builtin(builtin) => builtin.name().into(),135			Self::Builtin(builtin) => builtin.name().into(),
130		}136		}
131	}137	}
138	/// Call function using arguments evaluated in specified `call_ctx` [`Context`].
139	///
140	/// If `tailstrict` is specified - then arguments will be evaluated before being passed to function body.
132	pub fn evaluate(141	pub fn evaluate(
133		&self,142		&self,
134		s: State,143		s: State,
135		call_ctx: Context,144		call_ctx: Context,
136		loc: CallLocation,145		loc: CallLocation<'_>,
137		args: &dyn ArgsLike,146		args: &dyn ArgsLike,
138		tailstrict: bool,147		tailstrict: bool,
139	) -> Result<Val> {148	) -> Result<Val> {
156			Self::Builtin(b) => b.call(s, call_ctx, loc, args),165			Self::Builtin(b) => b.call(s, call_ctx, loc, args),
157		}166		}
158	}167	}
168	/// Helper method, which calls [`Self::evaluate`] with sensible defaults for native code.
159	pub fn evaluate_simple(&self, s: State, args: &dyn ArgsLike) -> Result<Val> {169	pub fn evaluate_simple(&self, s: State, args: &dyn ArgsLike) -> Result<Val> {
160		self.evaluate(s, Context::default(), CallLocation::native(), args, true)170		self.evaluate(s, Context::default(), CallLocation::native(), args, true)
161	}171	}
162172	/// Convert jsonnet function to plain `Fn` value.
173	pub fn into_native<D: NativeDesc>(self) -> D::Value {
174		D::into_native(self)
175	}
176
177	/// Is this function an indentity function.
178	///
179	/// Currently only works for builtin `std.id`, aka `Self::Id` value, `function(x) x` defined by jsonnet will not count as identity.
163	pub const fn is_identity(&self) -> bool {180	pub const fn is_identity(&self) -> bool {
164		matches!(self, Self::Id)181		matches!(self, Self::Id)
165	}182	}
183	/// Identity function value.
166	pub const fn identity() -> Self {184	pub const fn identity() -> Self {
167		Self::Id185		Self::Id
168	}186	}

22}22}
2323
24impl<T: ?Sized + Trace> Trace for TraceBox<T> {24impl<T: ?Sized + Trace> Trace for TraceBox<T> {
25	fn trace(&self, tracer: &mut Tracer) {25	fn trace(&self, tracer: &mut Tracer<'_>) {
26		self.0.trace(tracer);26		self.0.trace(tracer);
27	}27	}
2828
92where92where
93	V: Trace,93	V: Trace,
94{94{
95	fn trace(&self, tracer: &mut jrsonnet_gcmodule::Tracer) {95	fn trace(&self, tracer: &mut Tracer<'_>) {
96		for v in &self.0 {96		for v in &self.0 {
97			v.trace(tracer);97			v.trace(tracer);
98		}98		}
133	K: Trace,133	K: Trace,
134	V: Trace,134	V: Trace,
135{135{
136	fn trace(&self, tracer: &mut jrsonnet_gcmodule::Tracer) {136	fn trace(&self, tracer: &mut Tracer<'_>) {
137		for (k, v) in &self.0 {137		for (k, v) in &self.0 {
138			k.trace(tracer);138			k.trace(tracer);
139			v.trace(tracer);139			v.trace(tracer);

1//! jsonnet interpreter implementation
2
3#![deny(unsafe_op_in_unsafe_fn)]
1#![warn(clippy::all, clippy::nursery, clippy::pedantic)]4#![warn(
5	clippy::all,
6	clippy::nursery,
7	clippy::pedantic,
8	// missing_docs,
9	elided_lifetimes_in_paths,
10	explicit_outlives_requirements,
11	noop_method_call,
12	single_use_lifetimes,
13	variant_size_differences,
14	rustdoc::all
15)]
2#![allow(16#![allow(
3	macro_expanded_macro_exports_accessed_by_absolute_paths,17	macro_expanded_macro_exports_accessed_by_absolute_paths,
67use trace::{CompactFormat, TraceFormat};81use trace::{CompactFormat, TraceFormat};
68pub use val::{ManifestFormat, Thunk, Val};82pub use val::{ManifestFormat, Thunk, Val};
6983
84/// Thunk without bound `super`/`this`
85/// object inheritance may be overriden multiple times, and will be fixed only on field read
70pub trait Unbound: Trace {86pub trait Unbound: Trace {
87	/// Type of value after object context is bound
71	type Bound;88	type Bound;
89	/// Create value bound to specified object context
72	fn bind(&self, s: State, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;90	fn bind(&self, s: State, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;
73}91}
7492
93/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code
94/// Standard jsonnet fields are always unbound
75#[derive(Clone, Trace)]95#[derive(Clone, Trace)]
76pub enum LazyBinding {96pub enum MaybeUnbound {
97	/// Value needs to be bound to `this`/`super`
77	Bindable(Cc<TraceBox<dyn Unbound<Bound = Thunk<Val>>>>),98	Unbound(Cc<TraceBox<dyn Unbound<Bound = Thunk<Val>>>>),
99	/// Value is object-independent
78	Bound(Thunk<Val>),100	Bound(Thunk<Val>),
79}101}
80102
81impl Debug for LazyBinding {103impl Debug for MaybeUnbound {
82	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {104	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
83		write!(f, "LazyBinding")105		write!(f, "MaybeUnbound")
84	}106	}
85}107}
86impl LazyBinding {108impl MaybeUnbound {
109	/// Attach object context to value, if required
87	pub fn evaluate(110	pub fn evaluate(
88		&self,111		&self,
89		s: State,112		s: State,
90		sup: Option<ObjValue>,113		sup: Option<ObjValue>,
91		this: Option<ObjValue>,114		this: Option<ObjValue>,
92	) -> Result<Thunk<Val>> {115	) -> Result<Thunk<Val>> {
93		match self {116		match self {
94			Self::Bindable(v) => v.bind(s, sup, this),117			Self::Unbound(v) => v.bind(s, sup, this),
95			Self::Bound(v) => Ok(v.clone()),118			Self::Bound(v) => Ok(v.clone()),
96		}119		}
97	}120	}
98}121}
99122
100/// During import, this trait will be called to create initial context for file123/// During import, this trait will be called to create initial context for file.
101/// It may initialize global variables, stdlib for example124/// It may initialize global variables, stdlib for example.
102pub trait ContextInitializer {125pub trait ContextInitializer {
126	/// Initialize default file context.
103	fn initialize(&self, state: State, for_file: Source) -> Context;127	fn initialize(&self, state: State, for_file: Source) -> Context;
104128	/// Allows upcasting from abstract to concrete context initializer.
129	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.
105	fn as_any(&self) -> &dyn Any;130	fn as_any(&self) -> &dyn Any;
106}131}
107132
116	}141	}
117}142}
118143
144/// Dynamically reconfigurable evaluation settings
119pub struct EvaluationSettings {145pub struct EvaluationSettings {
120	/// Limits recursion by limiting the number of stack frames146	/// Limits recursion by limiting the number of stack frames
121	pub max_stack: usize,147	pub max_stack: usize,
401	/// Executes code creating a new stack frame427	/// Executes code creating a new stack frame
402	pub fn push<T>(428	pub fn push<T>(
403		&self,429		&self,
404		e: CallLocation,430		e: CallLocation<'_>,
405		frame_desc: impl FnOnce() -> String,431		frame_desc: impl FnOnce() -> String,
406		f: impl FnOnce() -> Result<T>,432		f: impl FnOnce() -> Result<T>,
407	) -> Result<T> {433	) -> Result<T> {
547573
548/// Internals574/// Internals
549impl State {575impl State {
550	// fn data(&self) -> Ref<EvaluationData> {
551	// 	self.0.data.borrow()
552	// }
553	fn data_mut(&self) -> RefMut<EvaluationData> {576	fn data_mut(&self) -> RefMut<'_, EvaluationData> {
554		self.0.data.borrow_mut()577		self.0.data.borrow_mut()
555	}578	}
556	pub fn settings(&self) -> Ref<EvaluationSettings> {579	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {
557		self.0.settings.borrow()580		self.0.settings.borrow()
558	}581	}
559	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {582	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {
560		self.0.settings.borrow_mut()583		self.0.settings.borrow_mut()
561	}584	}
562}585}
623	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {646	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {
624		self.import_resolver().resolve(path.as_ref())647		self.import_resolver().resolve(path.as_ref())
625	}648	}
626	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {649	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {
627		Ref::map(self.settings(), |s| &*s.import_resolver)650		Ref::map(self.settings(), |s| &*s.import_resolver)
628	}651	}
629	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {652	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {
630		self.settings_mut().import_resolver = resolver;653		self.settings_mut().import_resolver = resolver;
631	}654	}
632	pub fn context_initializer(&self) -> Ref<dyn ContextInitializer> {655	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {
633		Ref::map(self.settings(), |s| &*s.context_initializer)656		Ref::map(self.settings(), |s| &*s.context_initializer)
634	}657	}
635658
640		self.settings_mut().manifest_format = format;663		self.settings_mut().manifest_format = format;
641	}664	}
642665
643	pub fn trace_format(&self) -> Ref<dyn TraceFormat> {666	pub fn trace_format(&self) -> Ref<'_, dyn TraceFormat> {
644		Ref::map(self.settings(), |s| &*s.trace_format)667		Ref::map(self.settings(), |s| &*s.trace_format)
645	}668	}
646	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {669	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {

15	function::CallLocation,15	function::CallLocation,
16	gc::{GcHashMap, GcHashSet, TraceBox},16	gc::{GcHashMap, GcHashSet, TraceBox},
17	operator::evaluate_add_op,17	operator::evaluate_add_op,
18	throw, LazyBinding, Result, State, Thunk, Unbound, Val,18	throw, MaybeUnbound, Result, State, Thunk, Unbound, Val,
19};19};
2020
21#[cfg(not(feature = "exp-preserve-order"))]21#[cfg(not(feature = "exp-preserve-order"))]
100	pub add: bool,100	pub add: bool,
101	pub visibility: Visibility,101	pub visibility: Visibility,
102	original_index: FieldIndex,102	original_index: FieldIndex,
103	pub invoke: LazyBinding,103	pub invoke: MaybeUnbound,
104	pub location: Option<ExprLocation>,104	pub location: Option<ExprLocation>,
105}105}
106106
208		new.insert(key, value);208		new.insert(key, value);
209		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))209		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))
210	}210	}
211	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder> {211	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {
212		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())212		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())
213	}213	}
214214
239	}239	}
240240
241	/// Run callback for every field found in object241	/// Run callback for every field found in object
242	///
243	/// Returns true if ended prematurely
242	pub(crate) fn enum_fields(244	pub(crate) fn enum_fields(
243		&self,245		&self,
244		depth: SuperDepth,246		depth: SuperDepth,
500		self.assertions.push(assertion);502		self.assertions.push(assertion);
501		self503		self
502	}504	}
503	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder> {505	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {
504		let field_index = self.next_field_index;506		let field_index = self.next_field_index;
505		self.next_field_index = self.next_field_index.next();507		self.next_field_index = self.next_field_index.next();
506		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)508		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)
558		self.location = Some(location);560		self.location = Some(location);
559		self561		self
560	}562	}
561	fn build_member(self, binding: LazyBinding) -> (Kind, IStr, ObjMember) {563	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {
562		(564		(
563			self.kind,565			self.kind,
564			self.name,566			self.name,
574}576}
575577
576pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);578pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);
577impl<'v> ObjMemberBuilder<ValueBuilder<'v>> {579impl ObjMemberBuilder<ValueBuilder<'_>> {
578	pub fn value(self, s: State, value: Val) -> Result<()> {580	pub fn value(self, s: State, value: Val) -> Result<()> {
579		self.binding(s, LazyBinding::Bound(Thunk::evaluated(value)))581		self.binding(s, MaybeUnbound::Bound(Thunk::evaluated(value)))
580	}582	}
581	pub fn bindable(583	pub fn bindable(
582		self,584		self,
583		s: State,585		s: State,
584		bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>,586		bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>,
585	) -> Result<()> {587	) -> Result<()> {
586		self.binding(s, LazyBinding::Bindable(Cc::new(bindable)))588		self.binding(s, MaybeUnbound::Unbound(Cc::new(bindable)))
587	}589	}
588	pub fn binding(self, s: State, binding: LazyBinding) -> Result<()> {590	pub fn binding(self, s: State, binding: MaybeUnbound) -> Result<()> {
589		let (receiver, name, member) = self.build_member(binding);591		let (receiver, name, member) = self.build_member(binding);
590		let location = member.location.clone();592		let location = member.location.clone();
591		let old = receiver.0.map.insert(name.clone(), member);593		let old = receiver.0.map.insert(name.clone(), member);
601}603}
602604
603pub struct ExtendBuilder<'v>(&'v mut ObjValue);605pub struct ExtendBuilder<'v>(&'v mut ObjValue);
604impl<'v> ObjMemberBuilder<ExtendBuilder<'v>> {606impl ObjMemberBuilder<ExtendBuilder<'_>> {
605	pub fn value(self, value: Val) {607	pub fn value(self, value: Val) {
606		self.binding(LazyBinding::Bound(Thunk::evaluated(value)));608		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));
607	}609	}
608	pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>) {610	pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>) {
609		self.binding(LazyBinding::Bindable(Cc::new(bindable)));611		self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));
610	}612	}
611	pub fn binding(self, binding: LazyBinding) {613	pub fn binding(self, binding: MaybeUnbound) {
612		let (receiver, name, member) = self.build_member(binding);614		let (receiver, name, member) = self.build_member(binding);
613		let new = receiver.0.clone();615		let new = receiver.0.clone();
614		*receiver.0 = new.extend_with_raw_member(name, member);616		*receiver.0 = new.extend_with_raw_member(name, member);