git.delta.rocks / jrsonnet / refs/commits / 8db09e1bbe2e

99 "clap",99 "clap",
100]100]
101
102[[package]]
103name = "closure"
104version = "0.3.0"
105source = "registry+https://github.com/rust-lang/crates.io-index"
106checksum = "d6173fd61b610d15a7566dd7b7620775627441c4ab9dac8906e17cb93a24b782"
107101
108[[package]]102[[package]]
109name = "hashbrown"103name = "hashbrown"
164dependencies = [158dependencies = [
165 "clap",159 "clap",
166 "jrsonnet-evaluator",160 "jrsonnet-evaluator",
161 "jrsonnet-gc",
167 "jrsonnet-parser",162 "jrsonnet-parser",
168]163]
169164
175 "anyhow",170 "anyhow",
176 "base64",171 "base64",
177 "bincode",172 "bincode",
178 "closure",173 "jrsonnet-gc",
179 "jrsonnet-interner",174 "jrsonnet-interner",
180 "jrsonnet-parser",175 "jrsonnet-parser",
181 "jrsonnet-stdlib",176 "jrsonnet-stdlib",
188 "thiserror",183 "thiserror",
189]184]
185
186[[package]]
187name = "jrsonnet-gc"
188version = "0.4.2"
189source = "registry+https://github.com/rust-lang/crates.io-index"
190checksum = "68da8bc2f00117b1373bb8877af03b1d391e4c4800e6585d7279e5b99c919dde"
191dependencies = [
192 "jrsonnet-gc-derive",
193]
194
195[[package]]
196name = "jrsonnet-gc-derive"
197version = "0.4.1"
198source = "registry+https://github.com/rust-lang/crates.io-index"
199checksum = "adcba9c387b64b054f06cc4d724905296e21edeeb7506847f3299117a2d92d12"
200dependencies = [
201 "proc-macro2",
202 "quote",
203 "syn",
204 "synstructure",
205]
190206
191[[package]]207[[package]]
192name = "jrsonnet-interner"208name = "jrsonnet-interner"
193version = "0.3.8"209version = "0.3.8"
194dependencies = [210dependencies = [
211 "jrsonnet-gc",
195 "rustc-hash",212 "rustc-hash",
196 "serde",213 "serde",
197]214]
200name = "jrsonnet-parser"217name = "jrsonnet-parser"
201version = "0.3.8"218version = "0.3.8"
202dependencies = [219dependencies = [
220 "jrsonnet-gc",
203 "jrsonnet-interner",221 "jrsonnet-interner",
204 "jrsonnet-stdlib",222 "jrsonnet-stdlib",
205 "peg",223 "peg",
215name = "jrsonnet-types"233name = "jrsonnet-types"
216version = "0.3.8"234version = "0.3.8"
217dependencies = [235dependencies = [
236 "jrsonnet-gc",
218 "peg",237 "peg",
219]238]
220239
223version = "0.3.8"242version = "0.3.8"
224dependencies = [243dependencies = [
225 "jrsonnet-evaluator",244 "jrsonnet-evaluator",
245 "jrsonnet-gc",
226 "jrsonnet-parser",246 "jrsonnet-parser",
227]247]
228248
404 "unicode-xid",424 "unicode-xid",
405]425]
426
427[[package]]
428name = "synstructure"
429version = "0.12.4"
430source = "registry+https://github.com/rust-lang/crates.io-index"
431checksum = "b834f2d66f734cb897113e34aaff2f1ab4719ca946f9a7358dba8f8064148701"
432dependencies = [
433 "proc-macro2",
434 "quote",
435 "syn",
436 "unicode-xid",
437]
406438
407[[package]]439[[package]]
408name = "termcolor"440name = "termcolor"

10[dependencies]10[dependencies]
11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.8" }11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.8" }
12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.8" }12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.8" }
13jrsonnet-gc = { version = "0.4.2", features = ["derive"] }
1314
14[lib]15[lib]
15crate-type = ["cdylib"]16crate-type = ["cdylib"]

1use jrsonnet_evaluator::{error::Error, native::NativeCallback, EvaluationState, Val};1use jrsonnet_evaluator::{
2	error::{Error, LocError},
3	native::{NativeCallback, NativeCallbackHandler},
4	EvaluationState, Val,
5};
6use jrsonnet_gc::{unsafe_empty_trace, Finalize, Gc, Trace};
2use jrsonnet_parser::{Param, ParamsDesc};7use jrsonnet_parser::{Param, ParamsDesc};
3use std::{8use std::{
4	ffi::{c_void, CStr},9	ffi::{c_void, CStr},
5	os::raw::{c_char, c_int},10	os::raw::{c_char, c_int},
11	path::Path,
6	rc::Rc,12	rc::Rc,
7};13};
814
12	success: *mut c_int,18	success: *mut c_int,
13) -> *mut Val;19) -> *mut Val;
20
21struct JsonnetNativeCallbackHandler {
22	ctx: *const c_void,
23	cb: JsonnetNativeCallback,
24}
25impl Finalize for JsonnetNativeCallbackHandler {}
26unsafe impl Trace for JsonnetNativeCallbackHandler {
27	unsafe_empty_trace!();
28}
29impl NativeCallbackHandler for JsonnetNativeCallbackHandler {
30	fn call(&self, _from: Option<Rc<Path>>, args: &[Val]) -> Result<Val, LocError> {
31		let mut n_args = Vec::new();
32		for a in args {
33			n_args.push(Some(Box::new(a.clone())));
34		}
35		n_args.push(None);
36		let mut success = 1;
37		let v = unsafe {
38			(self.cb)(
39				self.ctx,
40				&n_args as *const _ as *const *const Val,
41				&mut success,
42			)
43		};
44		let v = unsafe { *Box::from_raw(v) };
45		if success == 1 {
46			Ok(v)
47		} else {
48			let e = v.try_cast_str("native error").expect("error msg");
49			Err(Error::RuntimeError(e).into())
50		}
51	}
52}
1453
15/// # Safety54/// # Safety
16#[no_mangle]55#[no_mangle]
3574
36	vm.add_native(75	vm.add_native(
37		name,76		name,
38		Rc::new(NativeCallback::new(params, move |_caller, args| {77		Gc::new(NativeCallback::new(
39			let mut n_args = Vec::new();78			params,
40			for a in args {
41				n_args.push(Some(Box::new(a.clone())));79			Box::new(JsonnetNativeCallbackHandler { ctx, cb }),
42			}
43			n_args.push(None);
44			let mut success = 1;
45			let v = cb(ctx, &n_args as *const _ as *const *const Val, &mut success);
46			let v = *Box::from_raw(v);
47			if success == 1 {
48				Ok(v)
49			} else {
50				let e = v.try_cast_str("native error").expect("error msg");
51				Err(Error::RuntimeError(e).into())
52			}
53		})),80		)),
54	)81	)
55}82}
5683

1//! Create values in VM1//! Create values in VM
22
3use jrsonnet_evaluator::{ArrValue, EvaluationState, ObjValue, Val};3use jrsonnet_evaluator::{ArrValue, EvaluationState, ObjValue, Val};
4use jrsonnet_gc::Gc;
4use std::{5use std::{
5	ffi::CStr,6	ffi::CStr,
6	os::raw::{c_char, c_double, c_int},7	os::raw::{c_char, c_double, c_int},
7	rc::Rc,
8};8};
99
10/// # Safety10/// # Safety
3838
39#[no_mangle]39#[no_mangle]
40pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {40pub extern "C" fn jsonnet_json_make_array(_vm: &EvaluationState) -> *mut Val {
41	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Rc::new(Vec::new())))))41	Box::into_raw(Box::new(Val::Arr(ArrValue::Eager(Gc::new(Vec::new())))))
42}42}
4343
44#[no_mangle]44#[no_mangle]

3//! In jrsonnet every value is immutable, and this code is probally broken3//! In jrsonnet every value is immutable, and this code is probally broken
44
5use jrsonnet_evaluator::{ArrValue, EvaluationState, LazyBinding, LazyVal, ObjMember, Val};5use jrsonnet_evaluator::{ArrValue, EvaluationState, LazyBinding, LazyVal, ObjMember, Val};
6use jrsonnet_gc::Gc;
6use jrsonnet_parser::Visibility;7use jrsonnet_parser::Visibility;
7use std::{ffi::CStr, os::raw::c_char, rc::Rc};8use std::{ffi::CStr, os::raw::c_char};
89
9/// # Safety10/// # Safety
10///11///
22				new.push(item);23				new.push(item);
23			}24			}
24			new.push(LazyVal::new_resolved(val.clone()));25			new.push(LazyVal::new_resolved(val.clone()));
25			*arr = Val::Arr(ArrValue::Lazy(Rc::new(new)));26			*arr = Val::Arr(ArrValue::Lazy(Gc::new(new)));
26		}27		}
27		_ => panic!("should receive array"),28		_ => panic!("should receive array"),
28	}29	}

8publish = false8publish = false
99
10[features]10[features]
11default = []11default = ["mimalloc"]
12# Use mimalloc as allocator12# Use mimalloc as allocator
13mimalloc = []13mimalloc = ["mimallocator"]
1414
15[dependencies]15[dependencies]
16jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.8" }16jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.8" }
17jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.8" }17jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.8" }
18jrsonnet-cli = { path = "../../crates/jrsonnet-cli", version = "0.3.8" }18jrsonnet-cli = { path = "../../crates/jrsonnet-cli", version = "0.3.8" }
19# TODO: Fix mimalloc compile errors, and use them
20mimallocator = { version = "0.1.3", optional = true }19mimallocator = { version = "0.1.3", optional = true }
21thiserror = "1.0"20thiserror = "1.0"
2221

1use clap::{AppSettings, Clap, IntoApp};1use clap::{AppSettings, Clap, IntoApp};
2use jrsonnet_cli::{ConfigureState, GeneralOpts, InputOpts, ManifestOpts, OutputOpts};2use jrsonnet_cli::{ConfigureState, GcOpts, GeneralOpts, InputOpts, ManifestOpts, OutputOpts};
3use jrsonnet_evaluator::{error::LocError, EvaluationState, ManifestFormat};3use jrsonnet_evaluator::{error::LocError, EvaluationState, ManifestFormat};
4use std::{4use std::{
5	fs::{create_dir_all, File},5	fs::{create_dir_all, File},
61	output: OutputOpts,61	output: OutputOpts,
62	#[clap(flatten)]62	#[clap(flatten)]
63	debug: DebugOpts,63	debug: DebugOpts,
64	#[clap(flatten)]
65	gc: GcOpts,
64}66}
6567
66fn main() {68fn main() {
114}116}
115117
116fn main_catch(opts: Opts) -> bool {118fn main_catch(opts: Opts) -> bool {
119	let _printer = opts.gc.stats_printer();
117	let state = EvaluationState::default();120	let state = EvaluationState::default();
118	if let Err(e) = main_real(&state, opts) {121	if let Err(e) = main_real(&state, opts) {
119		if let Error::Evaluation(e) = e {122		if let Error::Evaluation(e) = e {
127}130}
128131
129fn main_real(state: &EvaluationState, opts: Opts) -> Result<(), Error> {132fn main_real(state: &EvaluationState, opts: Opts) -> Result<(), Error> {
133	opts.gc.configure_global();
130	opts.general.configure(&state)?;134	opts.general.configure(&state)?;
131	opts.manifest.configure(&state)?;135	opts.manifest.configure(&state)?;
132136

10[dependencies]10[dependencies]
11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.6", features = ["explaining-traces"] }11jrsonnet-evaluator = { path = "../../crates/jrsonnet-evaluator", version = "0.3.6", features = ["explaining-traces"] }
12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.6" }12jrsonnet-parser = { path = "../../crates/jrsonnet-parser", version = "0.3.6" }
13jrsonnet-gc = { version = "0.4.2", features = ["derive", "unstable-config", "unstable-stats"] }
1314
14[dependencies.clap]15[dependencies.clap]
15git = "https://github.com/clap-rs/clap"16git = "https://github.com/clap-rs/clap"

96	}96	}
97}97}
98
99#[derive(Clap)]
100#[clap(help_heading = "GARBAGE COLLECTION")]
101pub struct GcOpts {
102	/// Min bytes allocated to start garbage collection
103	#[clap(long, default_value = "20000000")]
104	gc_initial_threshold: usize,
105	/// How much heap should grow after unsuccessful garbage collection
106	#[clap(long)]
107	gc_used_space_ratio: Option<f64>,
108	/// Do not skip gc on exit
109	#[clap(long)]
110	gc_collect_on_exit: bool,
111	/// Print gc stats before exit
112	#[clap(long)]
113	gc_print_stats: bool,
114	/// Force garbage collection before printing stats
115	/// Useful for checking for memory leaks
116	/// Does nothing useless --gc-print-stats is specified
117	#[clap(long)]
118	gc_collect_before_printing_stats: bool,
119}
120impl GcOpts {
121	pub fn stats_printer(&self) -> Option<GcStatsPrinter> {
122		self.gc_print_stats
123			.then(|| GcStatsPrinter(self.gc_collect_before_printing_stats))
124	}
125	pub fn configure_global(&self) {
126		jrsonnet_gc::configure(|config| {
127			config.leak_on_drop = !self.gc_collect_on_exit;
128			config.threshold = self.gc_initial_threshold;
129			if let Some(used_space_ratio) = self.gc_used_space_ratio {
130				config.used_space_ratio = used_space_ratio;
131			}
132		});
133	}
134}
135pub struct GcStatsPrinter(bool);
136impl Drop for GcStatsPrinter {
137	fn drop(&mut self) {
138		if self.0 {
139			jrsonnet_gc::force_collect()
140		}
141		eprintln!("=== GC STATS ===");
142		jrsonnet_gc::configure(|c| {
143			eprintln!("Final threshold: {:?}", c.threshold);
144		});
145		let stats = jrsonnet_gc::stats();
146		eprintln!("Collections performed: {}", stats.collections_performed);
147		eprintln!("Bytes still allocated: {}", stats.bytes_allocated);
148	}
149}
98150

30jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.8" }30jrsonnet-types = { path = "../jrsonnet-types", version = "0.3.8" }
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"
38jrsonnet-gc = { version = "0.4.2", features = ["derive"] }
4039
41[dependencies.anyhow]40[dependencies.anyhow]
42version = "1.0"41version = "1.0"

66
7jsonnet stdlib is embedded into evaluator, but there is different modes for this:7jsonnet stdlib is embedded into evaluator, but there is different modes for this:
88
9- `codegenerated-stdlib`
10  - generates source code for reproducing stdlib AST ([Example](https://gist.githubusercontent.com/CertainLach/7b3149df556f3406f5e9368aaa9f32ec/raw/0c80d8ab9aa7b9288c6219a2779cb2ab37287669/a.rs))
11  - fastest on interpretation, slowest on compilation (it takes more than 5 minutes to optimize them by llvm)
12- `serialized-stdlib`9- `serialized-stdlib`
13  - serializes standard library AST using serde10  - serializes standard library AST using serde
14  - slower than `codegenerated-stdlib` at runtime, but have no compilation speed penality11  - slower than `codegenerated-stdlib` at runtime, but have no compilation speed penality
23Can also be run via `cargo bench`20Can also be run via `cargo bench`
2421
25```markdown22```markdown
26# codegenerated-stdlib
27test tests::bench_codegen   ... bench:     401,696 ns/iter (+/- 38,521)
28# serialized-stdlib23# serialized-stdlib
29test tests::bench_serialize ... bench:   1,763,999 ns/iter (+/- 76,211)24test tests::bench_serialize ... bench:   1,763,999 ns/iter (+/- 76,211)
30# none25# none
34## Intrinsics29## Intrinsics
3530
36Some functions from stdlib are implemented as intrinsics31Some functions from stdlib are implemented as intrinsics
37
38### Intrinsic handling
39
40If indexed jsonnet object has field '__intrinsic_namespace__' of type 'string', then any not found field/method is resolved as `Val::Intrinsic(__intrinsic_namespace__, name)`
4132

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 jrsonnet_gc::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)]
11#[trivially_drop]
10pub enum FormatError {12pub enum FormatError {
11	#[error("truncated format code")]13	#[error("truncated format code")]
12	TruncatedFormatCode,14	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 jrsonnet_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		jrsonnet_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		Ok(DebugGcTraceValue::create(name, rest))
470	})
471}
448472
449fn builtin_base64(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {473fn builtin_base64(context: Context, _loc: Option<&ExprLocation>, args: &ArgsDesc) -> Result<Val> {
450	parse_args!(context, "base64", args, 1, [474	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 jrsonnet_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 jrsonnet_gc::{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)]
12#[trivially_drop]
11pub struct ContextCreator(pub Context, pub FutureWrapper<FxHashMap<IStr, LazyBinding>>);13pub struct ContextCreator(pub Context, pub FutureWrapper<FxHashMap<IStr, LazyBinding>>);
12impl ContextCreator {14impl ContextCreator {
13	pub fn create(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<Context> {15	pub fn create(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<Context> {
20	}22	}
21}23}
2224
25#[derive(Trace)]
26#[trivially_drop]
23struct ContextInternals {27struct ContextInternals {
24	dollar: Option<ObjValue>,28	dollar: Option<ObjValue>,
25	this: Option<ObjValue>,29	this: Option<ObjValue>,
26	super_obj: Option<ObjValue>,30	super_obj: Option<ObjValue>,
27	bindings: LayeredHashMap<LazyVal>,31	bindings: LayeredHashMap,
28}32}
29impl Debug for ContextInternals {33impl Debug for ContextInternals {
30	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {34	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
31		f.debug_struct("Context")35		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	}36	}
36}37}
3738
38#[derive(Debug, Clone)]39#[derive(Debug, Clone, Trace)]
40#[trivially_drop]
39pub struct Context(Rc<ContextInternals>);41pub struct Context(Gc<ContextInternals>);
40impl Context {42impl Context {
41	pub fn new_future() -> FutureWrapper<Self> {43	pub fn new_future() -> FutureWrapper<Self> {
42		FutureWrapper::new()44		FutureWrapper::new()
55	}57	}
5658
57	pub fn new() -> Self {59	pub fn new() -> Self {
58		Self(Rc::new(ContextInternals {60		Self(Gc::new(ContextInternals {
59			dollar: None,61			dollar: None,
60			this: None,62			this: None,
61			super_obj: None,63			super_obj: None,
81	pub fn with_var(self, name: IStr, value: Val) -> Self {83	pub fn with_var(self, name: IStr, value: Val) -> Self {
82		let mut new_bindings =84		let mut new_bindings =
83			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());85			FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());
84		new_bindings.insert(name, resolved_lazy_val!(value));86		new_bindings.insert(name, LazyVal::new_resolved(value));
85		self.extend(new_bindings, None, None, None)87		self.extend(new_bindings, None, None, None)
86	}88	}
8789
96		new_this: Option<ObjValue>,98		new_this: Option<ObjValue>,
97		new_super_obj: Option<ObjValue>,99		new_super_obj: Option<ObjValue>,
98	) -> Self {100	) -> 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 {101		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());102		let dollar = new_dollar.or_else(|| ctx.dollar.clone());
118				let this = new_this.or_else(|| ctx.this.clone());103		let this = new_this.or_else(|| ctx.this.clone());
119				let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());104		let super_obj = new_super_obj.or_else(|| ctx.super_obj.clone());
122				} else {107		} else {
123					ctx.bindings.clone().extend(new_bindings)108			ctx.bindings.clone().extend(new_bindings)
124				};109		};
125				Self(Rc::new(ContextInternals {110		Self(Gc::new(ContextInternals {
126					dollar,111			dollar,
127					this,112			this,
128					super_obj,113			super_obj,
129					bindings,114			bindings,
130				}))115		}))
131			}
132		}
133	}116	}
134	pub fn extend_bound(self, new_bindings: FxHashMap<IStr, LazyVal>) -> Self {117	pub fn extend_bound(self, new_bindings: FxHashMap<IStr, LazyVal>) -> Self {
135		let new_this = self.0.this.clone();118		let new_this = self.0.this.clone();
166149
167impl PartialEq for Context {150impl PartialEq for Context {
168	fn eq(&self, other: &Self) -> bool {151	fn eq(&self, other: &Self) -> bool {
169		Rc::ptr_eq(&self.0, &other.0)152		Gc::ptr_eq(&self.0, &other.0)
170	}153	}
171}154}
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}
188155