`afca77d1e35b`

9 files changed

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

2727
28use std::{28use std::{
29	any::Any,29	any::Any,
30	cell::{Ref, RefCell, RefMut},30	cell::{RefCell, RefMut},
31	fmt::{self, Debug},31	fmt::{self, Debug},
32	path::Path,32	path::Path,
33};33};
147	A @ B C D E F G147	A @ B C D E F G
148}148}
149
150/// Dynamically reconfigurable evaluation settings
151#[derive(Trace)]
152pub struct EvaluationSettings {
153	/// Context initializer, which will be used for imports and everything
154	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
155	pub context_initializer: TraceBox<dyn ContextInitializer>,
156	/// Used to resolve file locations/contents
157	pub import_resolver: TraceBox<dyn ImportResolver>,
158}
159impl Default for EvaluationSettings {
160	fn default() -> Self {
161		Self {
162			context_initializer: tb!(()),
163			import_resolver: tb!(DummyImportResolver),
164		}
165	}
166}
167149
168#[derive(Trace)]150#[derive(Trace)]
169struct FileData {151struct FileData {
207	}189	}
208}190}
209191
210#[derive(Default, Trace)]192#[derive(Trace)]
211pub struct EvaluationStateInternals {193pub struct EvaluationStateInternals {
212	/// Internal state194	/// Internal state
213	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,195	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,
214	/// Settings, safe to change at runtime196	/// Context initializer, which will be used for imports and everything
197	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
198	context_initializer: TraceBox<dyn ContextInitializer>,
199	/// Used to resolve file locations/contents
215	settings: RefCell<EvaluationSettings>,200	import_resolver: TraceBox<dyn ImportResolver>,
216}201}
217202
218/// Maintains stack trace and import resolution203/// Maintains stack trace and import resolution
219#[derive(Default, Clone, Trace)]204#[derive(Clone, Trace)]
220pub struct State(Cc<EvaluationStateInternals>);205pub struct State(Cc<EvaluationStateInternals>);
221206
222impl State {207impl State {
228		let file = match file {213		let file = match file {
229			RawEntryMut::Occupied(ref mut d) => d.get_mut(),214			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
230			RawEntryMut::Vacant(v) => {215			RawEntryMut::Vacant(v) => {
231				let data = self.settings().import_resolver.load_file_contents(&path)?;216				let data = self.import_resolver().load_file_contents(&path)?;
232				v.insert(217				v.insert(
233					path.clone(),218					path.clone(),
234					FileData::new_string(219					FileData::new_string(
252		let file = match file {237		let file = match file {
253			RawEntryMut::Occupied(ref mut d) => d.get_mut(),238			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
254			RawEntryMut::Vacant(v) => {239			RawEntryMut::Vacant(v) => {
255				let data = self.settings().import_resolver.load_file_contents(&path)?;240				let data = self.import_resolver().load_file_contents(&path)?;
256				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))241				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))
257					.1242					.1
258			}243			}
279		let file = match file {264		let file = match file {
280			RawEntryMut::Occupied(ref mut d) => d.get_mut(),265			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
281			RawEntryMut::Vacant(v) => {266			RawEntryMut::Vacant(v) => {
282				let data = self.settings().import_resolver.load_file_contents(&path)?;267				let data = self.import_resolver().load_file_contents(&path)?;
283				v.insert(268				v.insert(
284					path.clone(),269					path.clone(),
285					FileData::new_string(270					FileData::new_string(
350335
351	/// Creates context with all passed global variables336	/// Creates context with all passed global variables
352	pub fn create_default_context(&self, source: Source) -> Context {337	pub fn create_default_context(&self, source: Source) -> Context {
353		let context_initializer = &self.settings().context_initializer;
354		context_initializer.initialize(self.clone(), source)338		self.context_initializer().initialize(self.clone(), source)
355	}339	}
356340
357	/// Creates context with all passed global variables, calling custom modifier341	/// Creates context with all passed global variables, calling custom modifier
360		source: Source,344		source: Source,
361		context_initializer: impl ContextInitializer,345		context_initializer: impl ContextInitializer,
362	) -> Context {346	) -> Context {
363		let default_initializer = &self.settings().context_initializer;347		let default_initializer = self.context_initializer();
364		let mut builder = ContextBuilder::with_capacity(348		let mut builder = ContextBuilder::with_capacity(
365			self.clone(),349			self.clone(),
366			default_initializer.reserve_vars() + context_initializer.reserve_vars(),350			default_initializer.reserve_vars() + context_initializer.reserve_vars(),
409	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {393	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {
410		self.0.file_cache.borrow_mut()394		self.0.file_cache.borrow_mut()
411	}395	}
412	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {
413		self.0.settings.borrow()
414	}
415	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {
416		self.0.settings.borrow_mut()
417	}
418	pub fn add_global(&self, name: IStr, value: Thunk<Val>) {
419		#[derive(Trace)]
420		struct GlobalsCtx {
421			globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,
422			inner: TraceBox<dyn ContextInitializer>,
423		}
424		impl ContextInitializer for GlobalsCtx {
425			fn reserve_vars(&self) -> usize {
426				self.inner.reserve_vars() + self.globals.borrow().len()
427			}
428			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {
429				self.inner.populate(for_file, builder);
430				for (name, val) in self.globals.borrow().iter() {
431					builder.bind(name.clone(), val.clone());
432				}
433			}
434
435			fn as_any(&self) -> &dyn Any {
436				self
437			}
438		}
439		let mut settings = self.settings_mut();
440		let initializer = &mut settings.context_initializer;
441		if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {
442			global.globals.borrow_mut().insert(name, value);
443		} else {
444			let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));
445			settings.context_initializer = tb!(GlobalsCtx {
446				globals: {
447					let mut out = GcHashMap::with_capacity(1);
448					out.insert(name, value);
449					RefCell::new(out)
450				},
451				inner
452			});
453		}
454	}
455}396}
456397
457#[derive(Trace)]398#[derive(Trace)]
523	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {464	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {
524		self.import_resolver().resolve(path.as_ref())465		self.import_resolver().resolve(path.as_ref())
525	}466	}
526	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {467	pub fn import_resolver(&self) -> &dyn ImportResolver {
527		Ref::map(self.settings(), |s| &*s.import_resolver)468		&*self.0.import_resolver
528	}469	}
529	pub fn set_import_resolver(&self, resolver: impl ImportResolver) {
530		self.settings_mut().import_resolver = tb!(resolver);
531	}
532	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {470	pub fn context_initializer(&self) -> &dyn ContextInitializer {
533		Ref::map(self.settings(), |s| &*s.context_initializer)471		&*self.0.context_initializer
534	}472	}
535	pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {
536		self.settings_mut().context_initializer = tb!(initializer);
537	}
538}473}
474
475impl State {
476	pub fn builder() -> StateBuilder {
477		StateBuilder::default()
478	}
479}
480
481impl Default for State {
482	fn default() -> Self {
483		Self::builder().build()
484	}
485}
486
487#[derive(Default)]
488pub struct StateBuilder {
489	import_resolver: Option<TraceBox<dyn ImportResolver>>,
490	context_initializer: Option<TraceBox<dyn ContextInitializer>>,
491}
492impl StateBuilder {
493	pub fn import_resolver(&mut self, import_resolver: impl ImportResolver) -> &mut Self {
494		let _ = self.import_resolver.insert(tb!(import_resolver));
495		self
496	}
497	pub fn context_initializer(
498		&mut self,
499		context_initializer: impl ContextInitializer,
500	) -> &mut Self {
501		let _ = self.context_initializer.insert(tb!(context_initializer));
502		self
503	}
504	pub fn build(mut self) -> State {
505		State(Cc::new(EvaluationStateInternals {
506			file_cache: RefCell::new(GcHashMap::new()),
507			context_initializer: self.context_initializer.take().unwrap_or_else(|| tb!(())),
508			import_resolver: self
509				.import_resolver
510				.take()
511				.unwrap_or_else(|| tb!(DummyImportResolver)),
512		}))
513	}
514}
539515

modifiedtests/tests/as_native.rsdiff before after both

1use jrsonnet_evaluator::{Result, State};1use jrsonnet_evaluator::{trace::PathResolver, FileImportResolver, Result, State};
2use jrsonnet_stdlib::StateExt;2use jrsonnet_stdlib::ContextInitializer;
33
4mod common;4mod common;
55
6#[test]6#[test]
7fn as_native() -> Result<()> {7fn as_native() -> Result<()> {
8	let s = State::default();8	let mut s = State::builder();
9	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
10		.import_resolver(FileImportResolver::default());
9	s.with_stdlib();11	let s = s.build();
1012
11	let val = s.evaluate_snippet("snip".to_owned(), r#"function(a, b) a + b"#)?;13	let val = s.evaluate_snippet("snip".to_owned(), r"function(a, b) a + b")?;
12	let func = val.as_func().expect("this is function");14	let func = val.as_func().expect("this is function");
1315
14	let native = func.into_native::<((u32, u32), u32)>();16	let native = func.into_native::<((u32, u32), u32)>();

modifiedtests/tests/builtin.rsdiff before after both

22
3use jrsonnet_evaluator::{3use jrsonnet_evaluator::{
4	function::{builtin, builtin::Builtin, CallLocation, FuncVal},4	function::{builtin, builtin::Builtin, CallLocation, FuncVal},
5	parser::Source,
6	trace::PathResolver,
5	typed::Typed,7	typed::Typed,
6	ContextBuilder, Result, State, Thunk, Val,8	ContextBuilder, ContextInitializer, FileImportResolver, Result, State, Thunk, Val,
7};9};
10use jrsonnet_gcmodule::Trace;
8use jrsonnet_stdlib::StateExt;11use jrsonnet_stdlib::ContextInitializer as StdContextInitializer;
912
10#[builtin]13#[builtin]
11fn a() -> Result<u32> {14fn a() -> Result<u32> {
29fn native_add(a: u32, b: u32) -> Result<u32> {32fn native_add(a: u32, b: u32) -> Result<u32> {
30	Ok(a + b)33	Ok(a + b)
31}34}
35#[derive(Trace)]
36struct NativeAddContextInitializer;
37impl ContextInitializer for NativeAddContextInitializer {
38	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
39		builder.bind(
40			"nativeAdd",
41			Thunk::evaluated(Val::function(native_add::INST)),
42		);
43	}
44
45	fn as_any(&self) -> &dyn std::any::Any {
46		self
47	}
48}
3249
33#[test]50#[test]
34fn call_from_code() -> Result<()> {51fn call_from_code() -> Result<()> {
35	let s = State::default();52	let mut s = State::builder();
36	s.with_stdlib();
37	s.add_global(53	s.context_initializer((
38		"nativeAdd".into(),
39		Thunk::evaluated(Val::function(native_add::INST)),54		StdContextInitializer::new(PathResolver::new_cwd_fallback()),
55		NativeAddContextInitializer,
40	);56	))
57	.import_resolver(FileImportResolver::default());
58	let s = s.build();
4159
42	let v = s.evaluate_snippet(60	let v = s.evaluate_snippet(
43		"snip".to_owned(),61		"snip".to_owned(),
62fn curry_add(a: u32) -> Result<FuncVal> {80fn curry_add(a: u32) -> Result<FuncVal> {
63	Ok(FuncVal::builtin(curried_add { a }))81	Ok(FuncVal::builtin(curried_add { a }))
64}82}
83#[derive(Trace)]
84struct CurryAddContextInitializer;
85impl ContextInitializer for CurryAddContextInitializer {
86	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
87		builder.bind("curryAdd", Thunk::evaluated(Val::function(curry_add::INST)));
88	}
89
90	fn as_any(&self) -> &dyn std::any::Any {
91		self
92	}
93}
6594
66#[test]95#[test]
67fn nonstatic_builtin() -> Result<()> {96fn nonstatic_builtin() -> Result<()> {
68	let s = State::default();97	let mut s = State::builder();
69	s.with_stdlib();
70	s.add_global(98	s.context_initializer((
71		"curryAdd".into(),
72		Thunk::evaluated(Val::function(curry_add::INST)),99		StdContextInitializer::new(PathResolver::new_cwd_fallback()),
100		CurryAddContextInitializer,
73	);101	))
102	.import_resolver(FileImportResolver::default());
103	let s = s.build();
74104
75	let v = s.evaluate_snippet(105	let v = s.evaluate_snippet(
76		"snip".to_owned(),106		"snip".to_owned(),

modifiedtests/tests/common.rsdiff before after both

1use jrsonnet_evaluator::{1use jrsonnet_evaluator::{
2	bail,2	bail,
3	function::{builtin, FuncVal},3	function::{builtin, FuncVal},
4	parser::Source,
4	ObjValueBuilder, Result, State, Thunk, Val,5	ContextBuilder, ContextInitializer as ContextInitializerT, ObjValueBuilder, Result, Thunk, Val,
5};6};
7use jrsonnet_gcmodule::Trace;
68
7#[macro_export]9#[macro_export]
8macro_rules! ensure_eq {10macro_rules! ensure_eq {
74	}76	}
75}77}
7678
77#[allow(dead_code)]79#[derive(Trace)]
80pub struct ContextInitializer;
81impl ContextInitializerT for ContextInitializer {
78pub fn with_test(s: &State) {82	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
79	let mut bobj = ObjValueBuilder::new();83		let mut bobj = ObjValueBuilder::new();
80	bobj.method("assertThrow", assert_throw::INST);84		bobj.method("assertThrow", assert_throw::INST);
81	bobj.method("paramNames", param_names::INST);85		bobj.method("paramNames", param_names::INST);
8286
83	s.add_global("test".into(), Thunk::evaluated(Val::Obj(bobj.build())))87		builder.bind("test", Thunk::evaluated(Val::Obj(bobj.build())));
84}88	}
89
90	fn as_any(&self) -> &dyn std::any::Any {
91		self
92	}
93}
8594

modifiedtests/tests/golden.rsdiff before after both

8	trace::{CompactFormat, PathResolver, TraceFormat},8	trace::{CompactFormat, PathResolver, TraceFormat},
9	FileImportResolver, State,9	FileImportResolver, State,
10};10};
11use jrsonnet_stdlib::StateExt;11use jrsonnet_stdlib::ContextInitializer;
12mod common;12mod common;
13use common::ContextInitializer as TestContextInitializer;
1314
14fn run(file: &Path) -> String {15fn run(file: &Path) -> String {
15	let s = State::default();16	let mut s = State::builder();
16	s.with_stdlib();
17	common::with_test(&s);
18	s.set_import_resolver(FileImportResolver::default());17	s.context_initializer((
18		ContextInitializer::new(PathResolver::new_cwd_fallback()),
19		TestContextInitializer,
20	))
21	.import_resolver(FileImportResolver::default());
22	let s = s.build();
23
19	let trace_format = CompactFormat {24	let trace_format = CompactFormat {
20		resolver: PathResolver::FileName,25		resolver: PathResolver::FileName,

modifiedtests/tests/sanity.rsdiff before after both

1use jrsonnet_evaluator::{1use jrsonnet_evaluator::{
2	bail,2	bail,
3	trace::{CompactFormat, TraceFormat},3	trace::{CompactFormat, PathResolver, TraceFormat},
4	Result, State, Val,4	FileImportResolver, Result, State, Val,
5};5};
6use jrsonnet_stdlib::StateExt;6use jrsonnet_stdlib::ContextInitializer;
77
8mod common;8mod common;
99
10#[test]10#[test]
11fn assert_positive() -> Result<()> {11fn assert_positive() -> Result<()> {
12	let s = State::default();12	let mut s = State::builder();
13	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
14		.import_resolver(FileImportResolver::default());
13	s.with_stdlib();15	let s = s.build();
1416
15	let v = s.evaluate_snippet("snip".to_owned(), "assert 1 == 1: 'fail'; null")?;17	let v = s.evaluate_snippet("snip".to_owned(), "assert 1 == 1: 'fail'; null")?;
16	ensure_val_eq!(v, Val::Null);18	ensure_val_eq!(v, Val::Null);
2224
23#[test]25#[test]
24fn assert_negative() -> Result<()> {26fn assert_negative() -> Result<()> {
25	let s = State::default();27	let mut s = State::builder();
28	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
29		.import_resolver(FileImportResolver::default());
26	s.with_stdlib();30	let s = s.build();
31
27	let trace_format = CompactFormat::default();32	let trace_format = CompactFormat::default();
2833
38			bail!("assertion should fail")43			bail!("assertion should fail")
39		};44		};
40		let e = trace_format.format(&e).unwrap();45		let e = trace_format.format(&e).unwrap();
41		ensure!(e.starts_with("runtime error: Assertion failed. 1 != 2"))46		ensure!(e.starts_with("runtime error: assertion failed: A != B\nA: 1\nB: 2\n"));
42	}47	}
4348
44	Ok(())49	Ok(())

modifiedtests/tests/std_native.rsdiff before after both

88
9#[test]9#[test]
10fn std_native() {10fn std_native() {
11	let state = State::default();11	let mut state = State::builder();
12	let std = ContextInitializer::new(state.clone(), PathResolver::Absolute);12	let std = ContextInitializer::new(PathResolver::Absolute);
13	std.add_native("example", example_native::INST);13	std.add_native("example", example_native::INST);
14	state.set_context_initializer(std);14	state.context_initializer(std);
15	let state = state.build();
1516
16	assert!(state17	assert!(state
17		.evaluate_snippet("test", "std.native('example')(1, 3) == 4")18		.evaluate_snippet("test", "std.native('example')(1, 3) == 4")

modifiedtests/tests/suite.rsdiff before after both

4};4};
55
6use jrsonnet_evaluator::{6use jrsonnet_evaluator::{
7	trace::{CompactFormat, TraceFormat},7	trace::{CompactFormat, PathResolver, TraceFormat},
8	FileImportResolver, State, Val,8	FileImportResolver, State, Val,
9};9};
10use jrsonnet_stdlib::StateExt;10use jrsonnet_stdlib::ContextInitializer;
1111
12mod common;12mod common;
13use common::ContextInitializer as TestContextInitializer;
1314
14fn run(file: &Path) {15fn run(file: &Path) {
15	let s = State::default();16	let mut s = State::builder();
16	s.with_stdlib();
17	common::with_test(&s);
18	s.set_import_resolver(FileImportResolver::default());17	s.context_initializer((
18		ContextInitializer::new(PathResolver::new_cwd_fallback()),
19		TestContextInitializer,
20	))
21	.import_resolver(FileImportResolver::default());
22	let s = s.build();
23
19	let trace_format = CompactFormat::default();24	let trace_format = CompactFormat::default();
2025

modifiedtests/tests/typed_obj.rsdiff before after both

22
3use std::fmt::Debug;3use std::fmt::Debug;
44
5use jrsonnet_evaluator::{typed::Typed, Result, State};5use jrsonnet_evaluator::{trace::PathResolver, typed::Typed, Result, State};
6use jrsonnet_stdlib::StateExt;6use jrsonnet_stdlib::ContextInitializer;
77
8#[derive(Clone, Typed, PartialEq, Debug)]8#[derive(Clone, Typed, PartialEq, Debug)]
9struct A {9struct A {
2323
24#[test]24#[test]
25fn simple_object() -> Result<()> {25fn simple_object() -> Result<()> {
26	let s = State::default();26	let mut s = State::builder();
27	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
27	s.with_stdlib();28	let s = s.build();
29
28	let a = A::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;30	let a = A::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;
29	ensure_eq!(a, A { a: 1, b: 2 });31	ensure_eq!(a, A { a: 1, b: 2 });
4042
41#[test]43#[test]
42fn renamed_field() -> Result<()> {44fn renamed_field() -> Result<()> {
43	let s = State::default();45	let mut s = State::builder();
46	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
44	s.with_stdlib();47	let s = s.build();
48
45	let b = B::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, c: 2}")?)?;49	let b = B::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, c: 2}")?)?;
46	ensure_eq!(b, B { a: 1, b: 2 });50	ensure_eq!(b, B { a: 1, b: 2 });
6973
70#[test]74#[test]
71fn flattened_object() -> Result<()> {75fn flattened_object() -> Result<()> {
72	let s = State::default();76	let mut s = State::builder();
77	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
73	s.with_stdlib();78	let s = s.build();
79
74	let obj = Object::from_untyped(80	let obj = Object::from_untyped(
75		s.evaluate_snippet("snip".to_owned(), "{apiVersion: 'ver', kind: 'kind', b: 2}")?,81		s.evaluate_snippet("snip".to_owned(), "{apiVersion: 'ver', kind: 'kind', b: 2}")?,
100106
101#[test]107#[test]
102fn optional_field_some() -> Result<()> {108fn optional_field_some() -> Result<()> {
103	let s = State::default();109	let mut s = State::builder();
110	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
104	s.with_stdlib();111	let s = s.build();
112
105	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;113	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;
106	ensure_eq!(c, C { a: Some(1), b: 2 });114	ensure_eq!(c, C { a: Some(1), b: 2 });
114122
115#[test]123#[test]
116fn optional_field_none() -> Result<()> {124fn optional_field_none() -> Result<()> {
117	let s = State::default();125	let mut s = State::builder();
126	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
118	s.with_stdlib();127	let s = s.build();
128
119	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2}")?)?;129	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2}")?)?;
120	ensure_eq!(c, C { a: None, b: 2 });130	ensure_eq!(c, C { a: None, b: 2 });
140150
141#[test]151#[test]
142fn flatten_optional_some() -> Result<()> {152fn flatten_optional_some() -> Result<()> {
143	let s = State::default();153	let mut s = State::builder();
154	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
144	s.with_stdlib();155	let s = s.build();
156
145	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v:1}")?)?;157	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v:1}")?)?;
146	ensure_eq!(158	ensure_eq!(
160172
161#[test]173#[test]
162fn flatten_optional_none() -> Result<()> {174fn flatten_optional_none() -> Result<()> {
163	let s = State::default();175	let mut s = State::builder();
176	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
164	s.with_stdlib();177	let s = s.build();
178
165	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v: '1'}")?)?;179	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v: '1'}")?)?;
166	ensure_eq!(d, D { e: None, b: 2 });180	ensure_eq!(d, D { e: None, b: 2 });