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

30jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.7" }30jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.7" }
31pathdiff = "0.2.0"31pathdiff = "0.2.0"
32
33closure = "0.3.0"
3432
35md5 = "0.7.0"33md5 = "0.7.0"
36base64 = "0.13.0"34base64 = "0.13.0"
37rustc-hash = "1.1.0"35rustc-hash = "1.1.0"
3836
39thiserror = "1.0"37thiserror = "1.0"
38gc = { version = "0.4.1", features = ["derive"] }
4039
41[dependencies.anyhow]40[dependencies.anyhow]
42version = "1.0"41version = "1.0"

2#![allow(clippy::too_many_arguments)]2#![allow(clippy::too_many_arguments)]
33
4use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};4use crate::{error::Error::*, throw, LocError, ObjValue, Result, Val};
5use gc::{Finalize, Trace};
5use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
6use jrsonnet_types::ValType;7use jrsonnet_types::ValType;
7use thiserror::Error;8use thiserror::Error;
89
9#[derive(Debug, Clone, Error)]10#[derive(Debug, Clone, Error, Trace, Finalize)]
10pub enum FormatError {11pub enum FormatError {
11	#[error("truncated format code")]12	#[error("truncated format code")]
12	TruncatedFormatCode,13	TruncatedFormatCode,

126			buf.push('}');126			buf.push('}');
127		}127		}
128		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),128		Val::Func(_) => throw!(RuntimeError("tried to manifest function".into())),
129		Val::DebugGcTraceValue(v) => manifest_json_ex_buf(&v.value, buf, cur_padding, options)?,
129	};130	};
130	Ok(())131	Ok(())
131}132}

1use crate::{1use crate::{
2	equals,2	equals,
3	error::{Error::*, Result},3	error::{Error::*, Result},
4	parse_args, primitive_equals, push, throw, with_state, ArrValue, Context, EvaluationState,4	parse_args, primitive_equals, push, throw, with_state, ArrValue, Context, DebugGcTraceValue,
5	FuncVal, LazyVal, Val,5	EvaluationState, FuncVal, LazyVal, Val,
6};6};
7use format::{format_arr, format_obj};7use format::{format_arr, format_obj};
8use gc::Gc;
8use jrsonnet_interner::IStr;9use jrsonnet_interner::IStr;
9use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};10use jrsonnet_parser::{ArgsDesc, BinaryOpType, ExprLocation};
10use jrsonnet_types::ty;11use jrsonnet_types::ty;
68			("md5".into(), builtin_md5),69			("md5".into(), builtin_md5),
69			("base64".into(), builtin_base64),70			("base64".into(), builtin_base64),
70			("trace".into(), builtin_trace),71			("trace".into(), builtin_trace),
72			("gc".into(), builtin_gc),
73			("gcTrace".into(), builtin_gc_trace),
71			("join".into(), builtin_join),74			("join".into(), builtin_join),
72			("escapeStringJson".into(), builtin_escape_string_json),75			("escapeStringJson".into(), builtin_escape_string_json),
73			("manifestJsonEx".into(), builtin_manifest_json_ex),76			("manifestJsonEx".into(), builtin_manifest_json_ex),
301	parse_args!(context, "native", args, 1, [304	parse_args!(context, "native", args, 1, [
302		0, x: ty!(string) => Val::Str;305		0, x: ty!(string) => Val::Str;
303	], {306	], {
304		Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Rc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)307		Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Gc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)
305	})308	})
306}309}
307310
446	})449	})
447}450}
451
452fn builtin_gc(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
453	parse_args!(context, "gc", args, 1, [
454		0, rest: ty!(any);
455	], {
456		println!("GC start");
457		gc::force_collect();
458		println!("GC done");
459
460		Ok(rest)
461	})
462}
463
464fn builtin_gc_trace(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
465	parse_args!(context, "gcTrace", args, 2, [
466		0, name: ty!(string) => Val::Str;
467		1, rest: ty!(any);
468	], {
469
470		Ok(DebugGcTraceValue::new(name, rest))
471	})
472}
448473
449fn builtin_base64(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {474fn builtin_base64(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
450	parse_args!(context, "base64", args, 1, [475	parse_args!(context, "base64", args, 1, [

2	error::{Error, LocError, Result},2	error::{Error, LocError, Result},
3	throw, Context, FuncVal, Val,3	throw, Context, FuncVal, Val,
4};4};
5use std::rc::Rc;5use gc::{Finalize, Gc, Trace};
66
7#[derive(Debug, Clone, thiserror::Error)]7#[derive(Debug, Clone, thiserror::Error, Trace, Finalize)]
8pub enum SortError {8pub enum SortError {
9	#[error("sort key should be string or number")]9	#[error("sort key should be string or number")]
10	SortKeyShouldBeStringOrNumber,10	SortKeyShouldBeStringOrNumber,
59	Ok(sort_type)59	Ok(sort_type)
60}60}
6161
62pub fn sort(ctx: Context, mut values: Rc<Vec<Val>>, key_getter: &FuncVal) -> Result<Rc<Vec<Val>>> {62pub fn sort(ctx: Context, values: Gc<Vec<Val>>, key_getter: &FuncVal) -> Result<Gc<Vec<Val>>> {
63	if values.len() <= 1 {63	if values.len() <= 1 {
64		return Ok(values);64		return Ok(values);
65	}65	}
66	if key_getter.is_ident() {66	if key_getter.is_ident() {
67		let mvalues = Rc::make_mut(&mut values);67		let mut mvalues = (*values).clone();
68		let sort_type = get_sort_type(mvalues, |k| k)?;68		let sort_type = get_sort_type(&mut mvalues, |k| k)?;
69		match sort_type {69		match sort_type {
70			SortKeyType::Number => mvalues.sort_by_key(|v| match v {70			SortKeyType::Number => mvalues.sort_by_key(|v| match v {
71				Val::Num(n) => NonNaNf64(*n),71				Val::Num(n) => NonNaNf64(*n),
77			}),77			}),
78			SortKeyType::Unknown => unreachable!(),78			SortKeyType::Unknown => unreachable!(),
79		};79		};
80		Ok(values)80		Ok(Gc::new(mvalues))
81	} else {81	} else {
82		let mut vk = Vec::with_capacity(values.len());82		let mut vk = Vec::with_capacity(values.len());
83		for value in values.iter() {83		for value in values.iter() {
98			}),98			}),
99			SortKeyType::Unknown => unreachable!(),99			SortKeyType::Unknown => unreachable!(),
100		};100		};
101		Ok(Rc::new(vk.into_iter().map(|v| v.0).collect()))101		Ok(Gc::new(vk.into_iter().map(|v| v.0).collect()))
102	}102	}
103}103}
104104

1use crate::{1use crate::{
2	error::Error::*, map::LayeredHashMap, resolved_lazy_val, FutureWrapper, LazyBinding, LazyVal,2	error::Error::*, map::LayeredHashMap, FutureWrapper, LazyBinding, LazyVal, ObjValue, Result,
3	ObjValue, Result, Val,3	Val,
4};4};
5use gc::{Finalize, Gc, Trace};
5use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
6use rustc_hash::FxHashMap;7use rustc_hash::FxHashMap;
7use std::hash::BuildHasherDefault;8use std::fmt::Debug;
8use std::{fmt::Debug, rc::Rc};9use std::hash::BuildHasherDefault;
910
10#[derive(Clone)]11#[derive(Clone, Trace, Finalize)]
11pub struct ContextCreator(pub Context, pub FutureWrapper<FxHashMap<IStr, LazyBinding>>);12pub struct ContextCreator(pub Context, pub FutureWrapper<FxHashMap<IStr, LazyBinding>>);
12impl ContextCreator {13impl ContextCreator {
13	pub fn create(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<Context> {14	pub fn create(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<Context> {
20	}21	}
21}22}
2223
24#[derive(Trace, Finalize)]
23struct ContextInternals {25struct ContextInternals {
24	dollar: Option<ObjValue>,26	dollar: Option<ObjValue>,
25	this: Option<ObjValue>,27	this: Option<ObjValue>,
29impl Debug for ContextInternals {31impl Debug for ContextInternals {
30	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {32	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
31		f.debug_struct("Context")33		f.debug_struct("Context").finish()
32			.field("this", &self.this.as_ref().map(|e| Rc::as_ptr(&e.0)))
33			.field("bindings", &self.bindings)
34			.finish()
35	}34	}
36}35}
3736
38#[derive(Debug, Clone)]37#[derive(Debug, Clone, Trace, Finalize)]
39pub struct Context(Rc<ContextInternals>);38pub struct Context(Gc<ContextInternals>);
40impl Context {39impl Context {
41	pub fn new_future() -> FutureWrapper<Self> {40	pub fn new_future() -> FutureWrapper<Self> {
42		FutureWrapper::new()41		FutureWrapper::new()
55	}54	}
5655
57	pub fn new() -> Self {56	pub fn new() -> Self {
58		Self(Rc::new(ContextInternals {57		Self(Gc::new(ContextInternals {
59			dollar: None,58			dollar: None,
60			this: None,59			this: None,
61			super_obj: None,60			super_obj: None,
81	pub fn with_var(self, name: IStr, value: Val) -> Self {80	pub fn with_var(self, name: IStr, value: Val) -> Self {
82		let mut new_bindings =81		let mut new_bindings =
83			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());82			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
84		new_bindings.insert(name, resolved_lazy_val!(value));83		new_bindings.insert(name, LazyVal::new_resolved(value));
85		self.extend(new_bindings, None, None, None)84		self.extend(new_bindings, None, None, None)
86	}85	}
8786
96		new_this: Option<ObjValue>,95		new_this: Option<ObjValue>,
97		new_super_obj: Option<ObjValue>,96		new_super_obj: Option<ObjValue>,
98	) -> Self {97	) -> Self {
99		match Rc::try_unwrap(self.0) {
100			Ok(mut ctx) => {
101				// Extended context aren't used by anything else, we can freely mutate it without cloning
102				if let Some(dollar) = new_dollar {98		let ctx = &self.0;
103					ctx.dollar = Some(dollar);
104				}
105				if let Some(this) = new_this {
106					ctx.this = Some(this);
107				}
108				if let Some(super_obj) = new_super_obj {
109					ctx.super_obj = Some(super_obj);
110				}
111				if !new_bindings.is_empty() {
112					ctx.bindings = ctx.bindings.extend(new_bindings);
113				}
114				Self(Rc::new(ctx))
115			}
116			Err(ctx) => {
117				let dollar = new_dollar.or_else(|| ctx.dollar.clone());99		let dollar = new_dollar.or_else(|| ctx.dollar.clone());
118				let this = new_this.or_else(|| ctx.this.clone());100		let this = new_this.or_else(|| ctx.this.clone());
119				let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());101		let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());
122				} else {104		} else {
123					ctx.bindings.clone().extend(new_bindings)105			ctx.bindings.clone().extend(new_bindings)
124				};106		};
125				Self(Rc::new(ContextInternals {107		Self(Gc::new(ContextInternals {
126					dollar,108			dollar,
127					this,109			this,
128					super_obj,110			super_obj,
129					bindings,111			bindings,
130				}))112		}))
131			}
132		}
133	}113	}
134	pub fn extend_bound(self, new_bindings: FxHashMap<IStr, LazyVal>) -> Self {114	pub fn extend_bound(self, new_bindings: FxHashMap<IStr, LazyVal>) -> Self {
135		let new_this = self.0.this.clone();115		let new_this = self.0.this.clone();
166146
167impl PartialEq for Context {147impl PartialEq for Context {
168	fn eq(&self, other: &Self) -> bool {148	fn eq(&self, other: &Self) -> bool {
169		Rc::ptr_eq(&self.0, &other.0)149		Gc::ptr_eq(&self.0, &other.0)
170	}150	}
171}151}
172
173#[cfg(feature = "unstable")]
174#[derive(Debug, Clone)]
175pub struct WeakContext(std::rc::Weak<ContextInternals>);
176#[cfg(feature = "unstable")]
177impl WeakContext {
178	pub fn upgrade(&self) -> Context {
179		Context(self.0.upgrade().expect("context is removed"))
180	}
181}
182#[cfg(feature = "unstable")]
183impl PartialEq for WeakContext {
184	fn eq(&self, other: &Self) -> bool {
185		self.0.ptr_eq(&other.0)
186	}
187}
188152

1use std::{cell::RefCell, rc::Rc};1use gc::{Finalize, Gc, GcCell, Trace};
22
3#[derive(Clone)]3#[derive(Clone, Trace, Finalize)]
4pub struct FutureWrapper<V>(pub Rc<RefCell<Option<V>>>);4pub struct FutureWrapper<V: Trace + 'static>(pub Gc<GcCell<Option<V>>>);
5impl<T> FutureWrapper<T> {5impl<T: Trace + 'static> FutureWrapper<T> {
6	pub fn new() -> Self {6	pub fn new() -> Self {
7		Self(Rc::new(RefCell::new(None)))7		Self(Gc::new(GcCell::new(None)))
8	}8	}
9	pub fn fill(self, value: T) {9	pub fn fill(self, value: T) {
10		assert!(self.0.borrow().is_none(), "wrapper is filled already");10		assert!(self.0.borrow().is_none(), "wrapper is filled already");
11		self.0.borrow_mut().replace(value);11		self.0.borrow_mut().replace(value);
12	}12	}
13}13}
14impl<T: Clone> FutureWrapper<T> {14impl<T: Clone + Trace + 'static> FutureWrapper<T> {
15	pub fn unwrap(&self) -> T {15	pub fn unwrap(&self) -> T {
16		self.0.borrow().as_ref().cloned().unwrap()16		self.0.borrow().as_ref().cloned().unwrap()
17	}17	}
18}18}
1919
20impl<T> Default for FutureWrapper<T> {20impl<T: Trace + 'static> Default for FutureWrapper<T> {
21	fn default() -> Self {21	fn default() -> Self {
22		Self::new()22		Self::new()
23	}23	}

2	builtin::{format::FormatError, sort::SortError},2	builtin::{format::FormatError, sort::SortError},
3	typed::TypeLocError,3	typed::TypeLocError,
4};4};
5use gc::{Finalize, Trace};
5use jrsonnet_interner::IStr;6use jrsonnet_interner::IStr;
6use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};7use jrsonnet_parser::{BinaryOpType, ExprLocation, UnaryOpType};
7use jrsonnet_types::ValType;8use jrsonnet_types::ValType;
8use std::{path::PathBuf, rc::Rc};9use std::{path::PathBuf, rc::Rc};
9use thiserror::Error;10use thiserror::Error;
1011
11#[derive(Error, Debug, Clone)]12#[derive(Error, Debug, Clone, Trace, Finalize)]
12pub enum Error {13pub enum Error {
13	#[error("intrinsic not found: {0}")]14	#[error("intrinsic not found: {0}")]
14	IntrinsicNotFound(IStr),15	IntrinsicNotFound(IStr),
88	ImportSyntaxError {89	ImportSyntaxError {
89		path: Rc<PathBuf>,90		path: Rc<PathBuf>,
90		source_code: IStr,91		source_code: IStr,
92		#[unsafe_ignore_trace]
91		error: Box<jrsonnet_parser::ParseError>,93		error: Box<jrsonnet_parser::ParseError>,
92	},94	},
9395
94	#[error("runtime error: {0}")]96	#[error("runtime error: {0}")]
95	RuntimeError(IStr),97	RuntimeError(IStr),
96	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]98	#[error("stack overflow, try to reduce recursion, or set --max-stack to bigger value")]
97	StackOverflow,99	StackOverflow,
100	#[error("infinite recursion detected")]
101	RecursiveLazyValueEvaluation,
98	#[error("tried to index by fractional value")]102	#[error("tried to index by fractional value")]
99	FractionalIndex,103	FractionalIndex,
100	#[error("attempted to divide by zero")]104	#[error("attempted to divide by zero")]
142	}146	}
143}147}
144148
145#[derive(Clone, Debug)]149#[derive(Clone, Debug, Trace, Finalize)]
146pub struct StackTraceElement {150pub struct StackTraceElement {
147	pub location: Option<ExprLocation>,151	pub location: Option<ExprLocation>,
148	pub desc: String,152	pub desc: String,
149}153}
150#[derive(Debug, Clone)]154#[derive(Debug, Clone, Trace, Finalize)]
151pub struct StackTrace(pub Vec<StackTraceElement>);155pub struct StackTrace(pub Vec<StackTraceElement>);
152156
153#[derive(Debug, Clone)]157#[derive(Debug, Clone, Trace, Finalize)]
154pub struct LocError(Box<(Error, StackTrace)>);158pub struct LocError(Box<(Error, StackTrace)>);
155impl LocError {159impl LocError {
156	pub fn new(e: Error) -> Self {160	pub fn new(e: Error) -> Self {

1use crate::{1use crate::{
2	equals, error::Error::*, lazy_val, push, throw, with_state, ArrValue, Context, ContextCreator,2	equals, error::Error::*, push, throw, with_state, ArrValue, Bindable, Context, ContextCreator,
3	FuncDesc, FuncVal, FutureWrapper, LazyBinding, LazyVal, ObjMember, ObjValue, Result, Val,3	FuncDesc, FuncVal, FutureWrapper, LazyBinding, LazyVal, LazyValValue, ObjMember, ObjValue,
4	ObjectAssertion, Result, Val,
4};5};
5use closure::closure;6use gc::{custom_trace, Finalize, Gc, Trace};
6use jrsonnet_interner::IStr;7use jrsonnet_interner::IStr;
7use jrsonnet_parser::{8use jrsonnet_parser::{
8	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,9	ArgsDesc, AssertStmt, BinaryOpType, BindSpec, CompSpec, Expr, ExprLocation, FieldMember,
21	if let Some(params) = &b.params {22	if let Some(params) = &b.params {
22		let params = params.clone();23		let params = params.clone();
24
25		struct LazyMethodBinding {
26			context_creator: FutureWrapper<Context>,
27			name: IStr,
28			params: ParamsDesc,
29			value: LocExpr,
30		}
31		impl Finalize for LazyMethodBinding {}
32		unsafe impl Trace for LazyMethodBinding {
33			custom_trace!(this, {
34				mark(&this.context_creator);
35				mark(&this.name);
36				mark(&this.params);
37				mark(&this.value);
38			});
39		}
40		impl LazyValValue for LazyMethodBinding {
41			fn get(self: Box<Self>) -> Result<Val> {
42				Ok(evaluate_method(
43					self.context_creator.unwrap(),
44					self.name,
45					self.params,
46					self.value,
47				))
48			}
49		}
50
23		LazyVal::new(Box::new(move || {51		LazyVal::new(Box::new(LazyMethodBinding {
24			Ok(evaluate_method(
25				context_creator.unwrap(),52			context_creator,
26				b.name.clone(),53			name: b.name.clone(),
27				params.clone(),54			params,
28				b.value.clone(),55			value: b.value.clone(),
29			))
30		}))56		}))
31	} else {57	} else {
58		struct LazyNamedBinding {
59			context_creator: FutureWrapper<Context>,
60			name: IStr,
61			value: LocExpr,
62		}
63		impl Finalize for LazyNamedBinding {}
64		unsafe impl Trace for LazyNamedBinding {
65			custom_trace!(this, {
66				mark(&this.context_creator);
67				mark(&this.name);
68				mark(&this.value);
69			});
70		}
71		impl LazyValValue for LazyNamedBinding {
72			fn get(self: Box<Self>) -> Result<Val> {
73				evaluate_named(self.context_creator.unwrap(), &self.value, self.name)
74			}
75		}
32		LazyVal::new(Box::new(move || {76		LazyVal::new(Box::new(LazyNamedBinding {
33			evaluate_named(context_creator.unwrap(), &b.value, b.name.clone())77			context_creator,
78			name: b.name.clone(),
79			value: b.value,
34		}))80		}))
35	}81	}
36}82}
40	if let Some(params) = &b.params {86	if let Some(params) = &b.params {
41		let params = params.clone();87		let params = params.clone();
88
89		struct BindableMethodLazyVal {
90			this: Option<ObjValue>,
91			super_obj: Option<ObjValue>,
92
93			context_creator: ContextCreator,
94			name: IStr,
95			params: ParamsDesc,
96			value: LocExpr,
97		}
98		impl Finalize for BindableMethodLazyVal {}
99		unsafe impl Trace for BindableMethodLazyVal {
100			custom_trace!(this, {
101				mark(&this.this);
102				mark(&this.super_obj);
103				mark(&this.context_creator);
104				mark(&this.name);
105				mark(&this.params);
106				mark(&this.value);
107			});
108		}
109		impl LazyValValue for BindableMethodLazyVal {
110			fn get(self: Box<Self>) -> Result<Val> {
111				Ok(evaluate_method(
112					self.context_creator.create(self.this, self.super_obj)?,
113					self.name,
114					self.params,
115					self.value,
116				))
117			}
118		}
119
120		#[derive(Trace, Finalize)]
121		struct BindableMethod {
122			context_creator: ContextCreator,
123			name: IStr,
124			params: ParamsDesc,
125			value: LocExpr,
126		}
127		impl Bindable for BindableMethod {
128			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {
129				Ok(LazyVal::new(Box::new(BindableMethodLazyVal {
130					this: this.clone(),
131					super_obj: super_obj.clone(),
132
133					context_creator: self.context_creator.clone(),
134					name: self.name.clone(),
135					params: self.params.clone(),
136					value: self.value.clone(),
137				})))
138			}
139		}
140
42		(141		(
43			b.name.clone(),142			b.name.clone(),
44			LazyBinding::Bindable(Rc::new(move |this, super_obj| {143			LazyBinding::Bindable(Gc::new(Box::new(BindableMethod {
45				Ok(lazy_val!(
46					closure!(clone b, clone params, clone context_creator, || Ok(evaluate_method(144				context_creator,
47						context_creator.create(this.clone(), super_obj.clone())?,
48						b.name.clone(),145				name: b.name.clone(),
49						params.clone(),146				params,
50						b.value.clone(),147				value: b.value.clone(),
51					)))
52				))148			}))),
53			})),
54		)149		)
55	} else {150	} else {
151		struct BindableNamedLazyVal {
152			this: Option<ObjValue>,
153			super_obj: Option<ObjValue>,
154
155			context_creator: ContextCreator,
156			name: IStr,
157			value: LocExpr,
158		}
159		impl Finalize for BindableNamedLazyVal {}
160		unsafe impl Trace for BindableNamedLazyVal {
161			custom_trace!(this, {
162				mark(&this.this);
163				mark(&this.super_obj);
164				mark(&this.context_creator);
165				mark(&this.name);
166				mark(&this.value);
167			});
168		}
169		impl LazyValValue for BindableNamedLazyVal {
170			fn get(self: Box<Self>) -> Result<Val> {
171				evaluate_named(
172					self.context_creator.create(self.this, self.super_obj)?,
173					&self.value,
174					self.name,
175				)
176			}
177		}
178
179		#[derive(Trace, Finalize)]
180		struct BindableNamed {
181			context_creator: ContextCreator,
182			name: IStr,
183			value: LocExpr,
184		}
185		impl Bindable for BindableNamed {
186			fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {
187				Ok(LazyVal::new(Box::new(BindableNamedLazyVal {
188					this,
189					super_obj,
190
191					context_creator: self.context_creator.clone(),
192					name: self.name.clone(),
193					value: self.value.clone(),
194				})))
195			}
196		}
197
56		(198		(
57			b.name.clone(),199			b.name.clone(),
58			LazyBinding::Bindable(Rc::new(move |this, super_obj| {200			LazyBinding::Bindable(Gc::new(Box::new(BindableNamed {
59				Ok(lazy_val!(closure!(clone context_creator, clone b, ||201				context_creator,
60					evaluate_named(
61						context_creator.create(this.clone(), super_obj.clone())?,202				name: b.name.clone(),
62						&b.value,203				value: b.value.clone(),
63						b.name.clone()
64					)
65				)))204			}))),
66			})),
67		)205		)
68	}206	}
69}207}
70208
71pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {209pub fn evaluate_method(ctx: Context, name: IStr, params: ParamsDesc, body: LocExpr) -> Val {
72	Val::Func(Rc::new(FuncVal::Normal(FuncDesc {210	Val::Func(Gc::new(FuncVal::Normal(FuncDesc {
73		name,211		name,
74		ctx,212		ctx,
75		params,213		params,
105243
106pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {244pub fn evaluate_add_op(a: &Val, b: &Val) -> Result<Val> {
107	Ok(match (a, b) {245	Ok(match (a, b) {
246		(Val::DebugGcTraceValue(v1), Val::DebugGcTraceValue(v2)) => {
247			evaluate_add_op(&v1.value, &v2.value)?
248		}
108		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),249		(Val::Str(v1), Val::Str(v2)) => Val::Str(((**v1).to_owned() + v2).into()),
109250
110		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)251		// Can't use generic json serialization way, because it depends on number to string concatenation (std.jsonnet:890)
257	}398	}
258399
259	let mut new_members = FxHashMap::default();400	let mut new_members = FxHashMap::default();
260	let mut assertions = Vec::new();401	let mut assertions: Vec<Box<dyn ObjectAssertion>> = Vec::new();
261	for member in members.iter() {402	for member in members.iter() {
262		match member {403		match member {
263			Member::Field(FieldMember {404			Member::Field(FieldMember {
273				}414				}
274				let name = name.unwrap();415				let name = name.unwrap();
416
417				#[derive(Trace, Finalize)]
418				struct ObjMemberBinding {
419					context_creator: ContextCreator,
420					value: LocExpr,
421					name: IStr,
422				}
423				impl Bindable for ObjMemberBinding {
424					fn bind(
425						&self,
426						this: Option<ObjValue>,
427						super_obj: Option<ObjValue>,
428					) -> Result<LazyVal> {
429						Ok(LazyVal::new_resolved(evaluate_named(
430							self.context_creator.create(this, super_obj)?,
431							&self.value,
432							self.name.clone(),
433						)?))
434					}
435				}
275				new_members.insert(436				new_members.insert(
276					name.clone(),437					name.clone(),
277					ObjMember {438					ObjMember {
278						add: *plus,439						add: *plus,
279						visibility: *visibility,440						visibility: *visibility,
280						invoke: LazyBinding::Bindable(Rc::new(441						invoke: LazyBinding::Bindable(Gc::new(Box::new(ObjMemberBinding {
281							closure!(clone name, clone value, clone context_creator, |this, super_obj| {442							context_creator: context_creator.clone(),
282								Ok(LazyVal::new_resolved(evaluate_named(
283									context_creator.create(this, super_obj)?,
284									&value,443							value: value.clone(),
285									name.clone(),444							name,
286								)?))
287							}),445						}))),
288						)),
289						location: value.1.clone(),446						location: value.1.clone(),
290					},447					},
301					continue;458					continue;
302				}459				}
303				let name = name.unwrap();460				let name = name.unwrap();
461				#[derive(Trace, Finalize)]
462				struct ObjMemberBinding {
463					context_creator: ContextCreator,
464					value: LocExpr,
465					params: ParamsDesc,
466					name: IStr,
467				}
468				impl Bindable for ObjMemberBinding {
469					fn bind(
470						&self,
471						this: Option<ObjValue>,
472						super_obj: Option<ObjValue>,
473					) -> Result<LazyVal> {
474						Ok(LazyVal::new_resolved(evaluate_method(
475							self.context_creator.create(this, super_obj)?,
476							self.name.clone(),
477							self.params.clone(),
478							self.value.clone(),
479						)))
480					}
481				}
304				new_members.insert(482				new_members.insert(
305					name.clone(),483					name.clone(),
306					ObjMember {484					ObjMember {
307						add: false,485						add: false,
308						visibility: Visibility::Hidden,486						visibility: Visibility::Hidden,
309						invoke: LazyBinding::Bindable(Rc::new(487						invoke: LazyBinding::Bindable(Gc::new(Box::new(ObjMemberBinding {
310							closure!(clone value, clone context_creator, clone params, clone name, |this, super_obj| {488							context_creator: context_creator.clone(),
311								// TODO: Assert
312								Ok(LazyVal::new_resolved(evaluate_method(
313									context_creator.create(this, super_obj)?,
314									name.clone(),489							value: value.clone(),
315									params.clone(),490							params: params.clone(),
316									value.clone(),491							name,
317								)))
318							}),492						}))),
319						)),
320						location: value.1.clone(),493						location: value.1.clone(),
321					},494					},
322				);495				);
323			}496			}
324			Member::BindStmt(_) => {}497			Member::BindStmt(_) => {}
325			Member::AssertStmt(stmt) => {498			Member::AssertStmt(stmt) => {
499				struct ObjectAssert {
500					context_creator: ContextCreator,
501					assert: AssertStmt,
502				}
503				impl Finalize for ObjectAssert {}
504				unsafe impl Trace for ObjectAssert {
505					custom_trace!(this, {
506						mark(&this.context_creator);
507						mark(&this.assert);
508					});
509				}
510				impl ObjectAssertion for ObjectAssert {
511					fn run(
512						&self,
513						this: Option<ObjValue>,
514						super_obj: Option<ObjValue>,
515					) -> Result<()> {
516						let ctx = self.context_creator.create(this, super_obj)?;
517						evaluate_assert(ctx, &self.assert)
518					}
519				}
326				assertions.push(stmt.clone());520				assertions.push(Box::new(ObjectAssert {
521					context_creator: context_creator.clone(),
522					assert: stmt.clone(),
523				}));
327			}524			}
328		}525		}
329	}526	}
330	let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(assertions));527	let this = ObjValue::new(None, Gc::new(new_members), Gc::new(assertions));
331	future_this.fill(this.clone());528	future_this.fill(this.clone());
332	Ok(this)529	Ok(this)
333}530}
361				match key {558				match key {
362					Val::Null => {}559					Val::Null => {}
363					Val::Str(n) => {560					Val::Str(n) => {
561						#[derive(Trace, Finalize)]
562						struct ObjCompBinding {
563							context: Context,
564							value: LocExpr,
565						}
566						impl Bindable for ObjCompBinding {
567							fn bind(
568								&self,
569								this: Option<ObjValue>,
570								_super_obj: Option<ObjValue>,
571							) -> Result<LazyVal> {
572								Ok(LazyVal::new_resolved(evaluate(
573									self.context.clone().extend(
574										FxHashMap::default(),
575										None,
576										this,
577										None,
578									),
579									&self.value,
580								)?))
581							}
582						}
364						new_members.insert(583						new_members.insert(
365							n,584							n,
366							ObjMember {585							ObjMember {
367								add: false,586								add: false,
368								visibility: Visibility::Normal,587								visibility: Visibility::Normal,
369								invoke: LazyBinding::Bindable(Rc::new(588								invoke: LazyBinding::Bindable(Gc::new(Box::new(ObjCompBinding {
370									closure!(clone ctx, clone obj.value, |this, _super_obj| {589									context: ctx.clone(),
371										Ok(LazyVal::new_resolved(evaluate(ctx.clone().extend(FxHashMap::default(), None, this, None), &value)?))590									value: obj.value.clone(),
372									}),591								}))),
373								)),
374								location: obj.value.1.clone(),592								location: obj.value.1.clone(),
375							},593							},
381				Ok(())599				Ok(())
382			})?;600			})?;
383601
384			let this = ObjValue::new(context, None, Rc::new(new_members), Rc::new(Vec::new()));602			let this = ObjValue::new(None, Gc::new(new_members), Gc::new(Vec::new()));
385			future_this.fill(this.clone());603			future_this.fill(this.clone());
386			this604			this
387		}605		}
486							if let Some(v) = v.get(s.clone())? {704							if let Some(v) = v.get(s.clone())? {
487								Ok(v)705								Ok(v)
488							} else if v.get("__intrinsic_namespace__".into())?.is_some() {706							} else if v.get("__intrinsic_namespace__".into())?.is_some() {
489								Ok(Val::Func(Rc::new(FuncVal::Intrinsic(s))))707								Ok(Val::Func(Gc::new(FuncVal::Intrinsic(s))))
490							} else {708							} else {
491								throw!(NoSuchField(s))709								throw!(NoSuchField(s))
492							}710							}
549		Arr(items) => {767		Arr(items) => {
550			let mut out = Vec::with_capacity(items.len());768			let mut out = Vec::with_capacity(items.len());
551			for item in items {769			for item in items {
770				// TODO: Implement ArrValue::Lazy with same context for every element?
771				struct ArrayElement {
772					context: Context,
773					item: LocExpr,
774				}
775				impl Finalize for ArrayElement {}
776				unsafe impl Trace for ArrayElement {
777					custom_trace!(this, {
778						mark(&this.context);
779						mark(&this.item);
780					});
781				}
782				impl LazyValValue for ArrayElement {
783					fn get(self: Box<Self>) -> Result<Val> {
784						evaluate(self.context, &self.item)
785					}
786				}
552				out.push(LazyVal::new(Box::new(787				out.push(LazyVal::new(Box::new(ArrayElement {
553					closure!(clone context, clone item, || {788					context: context.clone(),
554						evaluate(context.clone(), &item)789					item: item.clone(),
555					}),
556				)));790				})));
557			}791			}
558			Val::Arr(out.into())792			Val::Arr(out.into())
559		}793		}
563				out.push(evaluate(ctx, expr)?);797				out.push(evaluate(ctx, expr)?);
564				Ok(())798				Ok(())
565			})?;799			})?;
566			Val::Arr(ArrValue::Eager(Rc::new(out)))800			Val::Arr(ArrValue::Eager(Gc::new(out)))
567		}801		}
568		Obj(body) => Val::Obj(evaluate_object(context, body)?),802		Obj(body) => Val::Obj(evaluate_object(context, body)?),
569		ObjExtend(s, t) => evaluate_add_op(803		ObjExtend(s, t) => evaluate_add_op(
576		Function(params, body) => {810		Function(params, body) => {
577			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())811			evaluate_method(context, "anonymous".into(), params.clone(), body.clone())
578		}812		}
579		Intrinsic(name) => Val::Func(Rc::new(FuncVal::Intrinsic(name.clone()))),813		Intrinsic(name) => Val::Func(Gc::new(FuncVal::Intrinsic(name.clone()))),
580		AssertExpr(assert, returned) => {814		AssertExpr(assert, returned) => {
581			evaluate_assert(context.clone(), assert)?;815			evaluate_assert(context.clone(), assert)?;
582			evaluate(context, returned)?816			evaluate(context, returned)?