git.delta.rocks / jrsonnet / refs/commits / 349c41065b93

1#![warn(clippy::all, clippy::nursery)]2#![allow(3	macro_expanded_macro_exports_accessed_by_absolute_paths,4	clippy::ptr_arg5)]67// For jrsonnet-macros8extern crate self as jrsonnet_evaluator;910mod builtin;11mod ctx;12mod dynamic;13pub mod error;14mod evaluate;15pub mod function;16mod import;17mod integrations;18mod map;19pub mod native;20mod obj;21pub mod trace;22pub mod typed;23mod val;2425pub use jrsonnet_parser as parser;2627pub use ctx::*;28pub use dynamic::*;29use error::{Error::*, LocError, Result, StackTraceElement};30pub use evaluate::*;31use function::{Builtin, TlaArg};32use gc::{GcHashMap, TraceBox};33use gcmodule::{Cc, Trace, Weak};34pub use import::*;35pub use jrsonnet_interner::IStr;36use jrsonnet_parser::*;37pub use obj::*;38use std::{39	cell::{Ref, RefCell, RefMut},40	collections::HashMap,41	fmt::Debug,42	path::{Path, PathBuf},43	rc::Rc,44};45use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};46pub use val::*;47pub mod gc;4849pub trait Bindable: Trace + 'static {50	fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal>;51}5253#[derive(Clone, Trace)]54pub enum LazyBinding {55	Bindable(Cc<TraceBox<dyn Bindable>>),56	Bound(LazyVal),57}5859impl Debug for LazyBinding {60	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {61		write!(f, "LazyBinding")62	}63}64impl LazyBinding {65	pub fn evaluate(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {66		match self {67			Self::Bindable(v) => v.bind(this, super_obj),68			Self::Bound(v) => Ok(v.clone()),69		}70	}71}7273pub struct EvaluationSettings {74	/// Limits recursion by limiting the number of stack frames75	pub max_stack: usize,76	/// Limits amount of stack trace items preserved77	pub max_trace: usize,78	/// Used for s`td.extVar`79	pub ext_vars: HashMap<IStr, Val>,80	/// Used for ext.native81	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,82	/// TLA vars83	pub tla_vars: HashMap<IStr, TlaArg>,84	/// Global variables are inserted in default context85	pub globals: HashMap<IStr, Val>,86	/// Used to resolve file locations/contents87	pub import_resolver: Box<dyn ImportResolver>,88	/// Used in manifestification functions89	pub manifest_format: ManifestFormat,90	/// Used for bindings91	pub trace_format: Box<dyn TraceFormat>,92}93impl Default for EvaluationSettings {94	fn default() -> Self {95		Self {96			max_stack: 200,97			max_trace: 20,98			globals: Default::default(),99			ext_vars: Default::default(),100			ext_natives: Default::default(),101			tla_vars: Default::default(),102			import_resolver: Box::new(DummyImportResolver),103			manifest_format: ManifestFormat::Json(4),104			trace_format: Box::new(CompactFormat {105				padding: 4,106				resolver: trace::PathResolver::Absolute,107			}),108		}109	}110}111112#[derive(Default)]113struct EvaluationData {114	/// Used for stack overflow detection, stacktrace is populated on unwind115	stack_depth: usize,116	/// Updated every time stack entry is popt117	stack_generation: usize,118119	breakpoints: Breakpoints,120	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces121	files: HashMap<Rc<Path>, FileData>,122	str_files: HashMap<Rc<Path>, IStr>,123}124125pub struct FileData {126	source_code: IStr,127	parsed: LocExpr,128	evaluated: Option<Val>,129}130131#[allow(clippy::type_complexity)]132pub struct Breakpoint {133	loc: ExprLocation,134	collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,135}136#[derive(Default)]137struct Breakpoints(Vec<Rc<Breakpoint>>);138impl Breakpoints {139	fn insert(140		&self,141		stack_depth: usize,142		stack_generation: usize,143		loc: &ExprLocation,144		result: Result<Val>,145	) -> Result<Val> {146		if self.0.is_empty() {147			return result;148		}149		for item in self.0.iter() {150			if item.loc.belongs_to(loc) {151				let mut collected = item.collected.borrow_mut();152				let (depth, vals) = collected.entry(stack_generation).or_default();153				if stack_depth > *depth {154					vals.clear();155				}156				vals.push(result.clone());157			}158		}159		result160	}161}162163#[derive(Default)]164pub struct EvaluationStateInternals {165	/// Internal state166	data: RefCell<EvaluationData>,167	/// Settings, safe to change at runtime168	settings: RefCell<EvaluationSettings>,169}170171thread_local! {172	/// Contains the state for a currently executed file.173	/// Global state is fine here.174	pub(crate) static EVAL_STATE: RefCell<Option<EvaluationState>> = RefCell::new(None)175}176pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {177	EVAL_STATE.with(|s| {178		f(s.borrow().as_ref().expect(179			"missing evaluation state, some functions should be called inside of run_in_state call",180		))181	})182}183pub fn push_frame<T>(184	e: Option<&ExprLocation>,185	frame_desc: impl FnOnce() -> String,186	f: impl FnOnce() -> Result<T>,187) -> Result<T> {188	with_state(|s| s.push(e, frame_desc, f))189}190191#[allow(dead_code)]192pub fn push_val_frame(193	e: &ExprLocation,194	frame_desc: impl FnOnce() -> String,195	f: impl FnOnce() -> Result<Val>,196) -> Result<Val> {197	with_state(|s| s.push_val(e, frame_desc, f))198}199#[allow(dead_code)]200pub fn push_description_frame<T>(201	frame_desc: impl FnOnce() -> String,202	f: impl FnOnce() -> Result<T>,203) -> Result<T> {204	with_state(|s| s.push_description(frame_desc, f))205}206207/// Maintains stack trace and import resolution208#[derive(Default, Clone)]209pub struct EvaluationState(Rc<EvaluationStateInternals>);210211impl EvaluationState {212	/// Parses and adds file as loaded213	pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {214		let parsed = parse(215			&source_code,216			&ParserSettings {217				file_name: path.clone(),218			},219		)220		.map_err(|error| ImportSyntaxError {221			error: Box::new(error),222			path: path.to_owned(),223			source_code: source_code.clone(),224		})?;225		self.add_parsed_file(path, source_code, parsed.clone())?;226227		Ok(parsed)228	}229230	pub fn reset_evaluation_state(&self, name: &Path) {231		self.data_mut()232			.files233			.get_mut(name)234			.unwrap()235			.evaluated236			.take();237	}238239	/// Adds file by source code and parsed expr240	pub fn add_parsed_file(241		&self,242		name: Rc<Path>,243		source_code: IStr,244		parsed: LocExpr,245	) -> Result<()> {246		self.data_mut().files.insert(247			name,248			FileData {249				source_code,250				parsed,251				evaluated: None,252			},253		);254255		Ok(())256	}257	pub fn get_source(&self, name: &Path) -> Option<IStr> {258		let ro_map = &self.data().files;259		ro_map.get(name).map(|value| value.source_code.clone())260	}261	pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {262		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)263	}264	pub fn map_from_source_location(265		&self,266		file: &Path,267		line: usize,268		column: usize,269	) -> Option<usize> {270		location_to_offset(&self.get_source(file).unwrap(), line, column)271	}272	pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {273		let file_path = self.resolve_file(from, path)?;274		{275			let data = self.data();276			let files = &data.files;277			if files.contains_key(&file_path as &Path) {278				drop(data);279				return self.evaluate_loaded_file_raw(&file_path);280			}281		}282		let contents = self.load_file_contents(&file_path)?;283		self.add_file(file_path.clone(), contents)?;284		self.evaluate_loaded_file_raw(&file_path)285	}286	pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {287		let path = self.resolve_file(from, path)?;288		if !self.data().str_files.contains_key(&path) {289			let file_str = self.load_file_contents(&path)?;290			self.data_mut().str_files.insert(path.clone(), file_str);291		}292		Ok(self.data().str_files.get(&path).cloned().unwrap())293	}294295	fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {296		let expr: LocExpr = {297			let ro_map = &self.data().files;298			let value = ro_map299				.get(name)300				.unwrap_or_else(|| panic!("file not added: {:?}", name));301			if let Some(ref evaluated) = value.evaluated {302				return Ok(evaluated.clone());303			}304			value.parsed.clone()305		};306		let value = evaluate(self.create_default_context(), &expr)?;307		{308			self.data_mut()309				.files310				.get_mut(name)311				.unwrap()312				.evaluated313				.replace(value.clone());314		}315		Ok(value)316	}317318	/// Adds standard library global variable (std) to this evaluator319	pub fn with_stdlib(&self) -> &Self {320		use jrsonnet_stdlib::STDLIB_STR;321		let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();322		self.run_in_state(|| {323			self.add_parsed_file(324				std_path.clone(),325				STDLIB_STR.to_owned().into(),326				builtin::get_parsed_stdlib(),327			)328			.unwrap();329			let val = self.evaluate_loaded_file_raw(&std_path).unwrap();330			self.settings_mut().globals.insert("std".into(), val);331		});332		self333	}334335	/// Creates context with all passed global variables336	pub fn create_default_context(&self) -> Context {337		let globals = &self.settings().globals;338		let mut new_bindings = GcHashMap::with_capacity(globals.len());339		for (name, value) in globals.iter() {340			new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));341		}342		Context::new().extend_bound(new_bindings)343	}344345	/// Executes code creating a new stack frame346	pub fn push<T>(347		&self,348		e: Option<&ExprLocation>,349		frame_desc: impl FnOnce() -> String,350		f: impl FnOnce() -> Result<T>,351	) -> Result<T> {352		{353			let mut data = self.data_mut();354			let stack_depth = &mut data.stack_depth;355			if *stack_depth > self.max_stack() {356				// Error creation uses data, so i drop guard here357				drop(data);358				throw!(StackOverflow);359			} else {360				*stack_depth += 1;361			}362		}363		let result = f();364		{365			let mut data = self.data_mut();366			data.stack_depth -= 1;367			data.stack_generation += 1;368		}369		if let Err(mut err) = result {370			err.trace_mut().0.push(StackTraceElement {371				location: e.cloned(),372				desc: frame_desc(),373			});374			return Err(err);375		}376		result377	}378379	/// Executes code creating a new stack frame380	pub fn push_val(381		&self,382		e: &ExprLocation,383		frame_desc: impl FnOnce() -> String,384		f: impl FnOnce() -> Result<Val>,385	) -> Result<Val> {386		{387			let mut data = self.data_mut();388			let stack_depth = &mut data.stack_depth;389			if *stack_depth > self.max_stack() {390				// Error creation uses data, so i drop guard here391				drop(data);392				throw!(StackOverflow);393			} else {394				*stack_depth += 1;395			}396		}397		let mut result = f();398		{399			let mut data = self.data_mut();400			data.stack_depth -= 1;401			data.stack_generation += 1;402			result = data403				.breakpoints404				.insert(data.stack_depth, data.stack_generation, e, result);405		}406		if let Err(mut err) = result {407			err.trace_mut().0.push(StackTraceElement {408				location: Some(e.clone()),409				desc: frame_desc(),410			});411			return Err(err);412		}413		result414	}415	/// Executes code creating a new stack frame416	pub fn push_description<T>(417		&self,418		frame_desc: impl FnOnce() -> String,419		f: impl FnOnce() -> Result<T>,420	) -> Result<T> {421		{422			let mut data = self.data_mut();423			let stack_depth = &mut data.stack_depth;424			if *stack_depth > self.max_stack() {425				// Error creation uses data, so i drop guard here426				drop(data);427				throw!(StackOverflow);428			} else {429				*stack_depth += 1;430			}431		}432		let result = f();433		{434			let mut data = self.data_mut();435			data.stack_depth -= 1;436			data.stack_generation += 1;437		}438		if let Err(mut err) = result {439			err.trace_mut().0.push(StackTraceElement {440				location: None,441				desc: frame_desc(),442			});443			return Err(err);444		}445		result446	}447448	/// Runs passed function in state (required if function needs to modify stack trace)449	pub fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {450		EVAL_STATE.with(|v| {451			let has_state = v.borrow().is_some();452			if !has_state {453				v.borrow_mut().replace(self.clone());454			}455			let result = f();456			if !has_state {457				v.borrow_mut().take();458			}459			result460		})461	}462	pub fn run_in_state_with_breakpoint(463		&self,464		bp: Rc<Breakpoint>,465		f: impl FnOnce() -> Result<()>,466	) -> Result<()> {467		{468			let mut data = self.data_mut();469			data.breakpoints.0.push(bp);470		}471472		let result = self.run_in_state(f);473474		{475			let mut data = self.data_mut();476			data.breakpoints.0.pop();477		}478479		result480	}481482	pub fn stringify_err(&self, e: &LocError) -> String {483		let mut out = String::new();484		self.settings()485			.trace_format486			.write_trace(&mut out, self, e)487			.unwrap();488		out489	}490491	pub fn manifest(&self, val: Val) -> Result<IStr> {492		self.run_in_state(|| {493			push_description_frame(494				|| "manifestification".to_string(),495				|| val.manifest(&self.manifest_format()),496			)497		})498	}499	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {500		self.run_in_state(|| val.manifest_multi(&self.manifest_format()))501	}502	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {503		self.run_in_state(|| val.manifest_stream(&self.manifest_format()))504	}505506	/// If passed value is function then call with set TLA507	pub fn with_tla(&self, val: Val) -> Result<Val> {508		self.run_in_state(|| {509			Ok(match val {510				Val::Func(func) => push_description_frame(511					|| "during TLA call".to_owned(),512					|| {513						func.evaluate(514							self.create_default_context(),515							None,516							&self.settings().tla_vars,517							true,518						)519					},520				)?,521				v => v,522			})523		})524	}525}526527/// Internals528impl EvaluationState {529	fn data(&self) -> Ref<EvaluationData> {530		self.0.data.borrow()531	}532	fn data_mut(&self) -> RefMut<EvaluationData> {533		self.0.data.borrow_mut()534	}535	pub fn settings(&self) -> Ref<EvaluationSettings> {536		self.0.settings.borrow()537	}538	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {539		self.0.settings.borrow_mut()540	}541}542543/// Raw methods evaluate passed values but don't perform TLA execution544impl EvaluationState {545	pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {546		self.run_in_state(|| self.import_file(&std::env::current_dir().expect("cwd"), name))547	}548	pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {549		self.run_in_state(|| self.import_file(&PathBuf::from("."), name))550	}551	/// Parses and evaluates the given snippet552	pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {553		let parsed = parse(554			&code,555			&ParserSettings {556				file_name: source.clone(),557			},558		)559		.map_err(|e| ImportSyntaxError {560			path: source.clone(),561			source_code: code.clone(),562			error: Box::new(e),563		})?;564		self.add_parsed_file(source, code, parsed.clone())?;565		self.evaluate_expr_raw(parsed)566	}567	/// Evaluates the parsed expression568	pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {569		self.run_in_state(|| evaluate(self.create_default_context(), &code))570	}571}572573/// Settings utilities574impl EvaluationState {575	pub fn add_ext_var(&self, name: IStr, value: Val) {576		self.settings_mut().ext_vars.insert(name, value);577	}578	pub fn add_ext_str(&self, name: IStr, value: IStr) {579		self.add_ext_var(name, Val::Str(value));580	}581	pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {582		let value =583			self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;584		self.add_ext_var(name, value);585		Ok(())586	}587588	pub fn add_tla(&self, name: IStr, value: Val) {589		self.settings_mut()590			.tla_vars591			.insert(name, TlaArg::Val(value));592	}593	pub fn add_tla_str(&self, name: IStr, value: IStr) {594		self.settings_mut()595			.tla_vars596			.insert(name, TlaArg::String(value));597	}598	pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {599		let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;600		self.settings_mut()601			.tla_vars602			.insert(name, TlaArg::Code(parsed));603		Ok(())604	}605606	pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {607		self.settings().import_resolver.resolve_file(from, path)608	}609	pub fn load_file_contents(&self, path: &Path) -> Result<IStr> {610		self.settings().import_resolver.load_file_contents(path)611	}612613	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {614		Ref::map(self.settings(), |s| &*s.import_resolver)615	}616	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {617		self.settings_mut().import_resolver = resolver;618	}619620	pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {621		self.settings_mut().ext_natives.insert(name, cb);622	}623624	pub fn manifest_format(&self) -> ManifestFormat {625		self.settings().manifest_format.clone()626	}627	pub fn set_manifest_format(&self, format: ManifestFormat) {628		self.settings_mut().manifest_format = format;629	}630631	pub fn trace_format(&self) -> Ref<dyn TraceFormat> {632		Ref::map(self.settings(), |s| &*s.trace_format)633	}634	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {635		self.settings_mut().trace_format = format;636	}637638	pub fn max_trace(&self) -> usize {639		self.settings().max_trace640	}641	pub fn set_max_trace(&self, trace: usize) {642		self.settings_mut().max_trace = trace;643	}644645	pub fn max_stack(&self) -> usize {646		self.settings().max_stack647	}648	pub fn set_max_stack(&self, trace: usize) {649		self.settings_mut().max_stack = trace;650	}651}652653pub fn cc_ptr_eq<T>(a: &Cc<T>, b: &Cc<T>) -> bool {654	let a = a as &T;655	let b = b as &T;656	std::ptr::eq(a, b)657}658659fn weak_raw<T>(a: Weak<T>) -> *const () {660	unsafe { std::mem::transmute(a) }661}662fn weak_ptr_eq<T>(a: Weak<T>, b: Weak<T>) -> bool {663	std::ptr::eq(weak_raw(a), weak_raw(b))664}665666#[test]667fn weak_unsafe() {668	let a = Cc::new(1);669	let b = Cc::new(2);670671	let aw1 = a.clone().downgrade();672	let aw2 = a.clone().downgrade();673	let aw3 = a.clone().downgrade();674675	let bw = b.clone().downgrade();676677	assert!(weak_ptr_eq(aw1, aw2));678	assert!(!weak_ptr_eq(aw3, bw));679}680681#[cfg(test)]682pub mod tests {683	use super::Val;684	use crate::{685		error::Error::*, function::BuiltinParam, gc::TraceBox, native::NativeCallbackHandler,686		primitive_equals, EvaluationState,687	};688	use gcmodule::{Cc, Trace};689	use jrsonnet_interner::IStr;690	use jrsonnet_parser::*;691	use std::{692		path::{Path, PathBuf},693		rc::Rc,694	};695696	#[test]697	#[should_panic]698	fn eval_state_stacktrace() {699		let state = EvaluationState::default();700		state.run_in_state(|| {701			state702				.push(703					Some(&ExprLocation(PathBuf::from("test1.jsonnet").into(), 10, 20)),704					|| "outer".to_owned(),705					|| {706						state.push(707							Some(&ExprLocation(PathBuf::from("test2.jsonnet").into(), 30, 40)),708							|| "inner".to_owned(),709							|| Err(RuntimeError("".into()).into()),710						)?;711						Ok(Val::Null)712					},713				)714				.unwrap();715		});716	}717718	#[test]719	fn eval_state_standard() {720		let state = EvaluationState::default();721		state.with_stdlib();722		assert!(primitive_equals(723			&state724				.evaluate_snippet_raw(725					PathBuf::from("raw.jsonnet").into(),726					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#.into()727				)728				.unwrap(),729			&Val::Bool(true),730		)731		.unwrap());732	}733734	macro_rules! eval {735		($str: expr) => {{736			let evaluator = EvaluationState::default();737			evaluator.with_stdlib();738			evaluator.run_in_state(|| {739				evaluator740					.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())741					.unwrap()742			})743		}};744	}745	macro_rules! eval_json {746		($str: expr) => {{747			let evaluator = EvaluationState::default();748			evaluator.with_stdlib();749			evaluator.run_in_state(|| {750				evaluator751					.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())752					.unwrap()753					.to_json(0)754					.unwrap()755					.replace("\n", "")756			})757		}};758	}759760	/// Asserts given code returns `true`761	macro_rules! assert_eval {762		($str: expr) => {763			assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())764		};765	}766767	/// Asserts given code returns `false`768	macro_rules! assert_eval_neg {769		($str: expr) => {770			assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())771		};772	}773	macro_rules! assert_json {774		($str: expr, $out: expr) => {775			assert_eq!(eval_json!($str), $out.replace("\t", ""))776		};777	}778779	/// Sanity checking, before trusting to another tests780	#[test]781	fn equality_operator() {782		assert_eval!("2 == 2");783		assert_eval_neg!("2 != 2");784		assert_eval!("2 != 3");785		assert_eval_neg!("2 == 3");786		assert_eval!("'Hello' == 'Hello'");787		assert_eval_neg!("'Hello' != 'Hello'");788		assert_eval!("'Hello' != 'World'");789		assert_eval_neg!("'Hello' == 'World'");790	}791792	#[test]793	fn math_evaluation() {794		assert_eval!("2 + 2 * 2 == 6");795		assert_eval!("3 + (2 + 2 * 2) == 9");796	}797798	#[test]799	fn string_concat() {800		assert_eval!("'Hello' + 'World' == 'HelloWorld'");801		assert_eval!("'Hello' * 3 == 'HelloHelloHello'");802		assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");803	}804805	#[test]806	fn faster_join() {807		assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");808		assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");809	}810811	#[test]812	fn function_contexts() {813		assert_eval!(814			r#"815				local k = {816					t(name = self.h): [self.h, name],817					h: 3,818				};819				local f = {820					t: k.t(),821					h: 4,822				};823				f.t[0] == f.t[1]824			"#825		);826	}827828	#[test]829	fn local() {830		assert_eval!("local a = 2; local b = 3; a + b == 5");831		assert_eval!("local a = 1, b = a + 1; a + b == 3");832		assert_eval!("local a = 1; local a = 2; a == 2");833	}834835	#[test]836	fn object_lazyness() {837		assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);838	}839840	#[test]841	fn object_inheritance() {842		assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);843	}844845	#[test]846	fn object_assertion_success() {847		eval!("{assert \"a\" in self} + {a:2}");848	}849850	#[test]851	fn object_assertion_error() {852		eval!("{assert \"a\" in self}");853	}854855	#[test]856	fn lazy_args() {857		eval!("local test(a) = 2; test(error '3')");858	}859860	#[test]861	#[should_panic]862	fn tailstrict_args() {863		eval!("local test(a) = 2; test(error '3') tailstrict");864	}865866	#[test]867	#[should_panic]868	fn no_binding_error() {869		eval!("a");870	}871872	#[test]873	fn test_object() {874		assert_json!("{a:2}", r#"{"a": 2}"#);875		assert_json!("{a:2+2}", r#"{"a": 4}"#);876		assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);877		assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);878		assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);879		assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);880		assert_json!(881			r#"882				{883					name: "Alice",884					welcome: "Hello " + self.name + "!",885				}886			"#,887			r#"{"name": "Alice","welcome": "Hello Alice!"}"#888		);889		assert_json!(890			r#"891				{892					name: "Alice",893					welcome: "Hello " + self.name + "!",894				} + {895					name: "Bob"896				}897			"#,898			r#"{"name": "Bob","welcome": "Hello Bob!"}"#899		);900	}901902	#[test]903	fn functions() {904		assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");905		assert_json!(906			r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,907			r#""HelloDearWorld""#908		);909	}910911	#[test]912	fn local_methods() {913		assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");914		assert_json!(915			r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,916			r#""HelloDearWorld""#917		);918	}919920	#[test]921	fn object_locals() {922		assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);923		assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);924		assert_json!(925			r#"{local a = function (b) {[b]:4}, test: a("test")}"#,926			r#"{"test": {"test": 4}}"#927		);928	}929930	#[test]931	fn object_comp() {932		assert_json!(933			r#"{local t = "a", ["h"+i+"_"+z]: if "h"+(i-1)+"_"+z in self then t+1 else 0+t for i in [1,2,3] for z in [2,3,4] if z != i}"#,934			"{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"935		)936	}937938	#[test]939	fn direct_self() {940		println!(941			"{:#?}",942			eval!(943				r#"944					{945						local me = self,946						a: 3,947						b(): me.a,948					}949				"#950			)951		);952	}953954	#[test]955	fn indirect_self() {956		// `self` assigned to `me` was lost when being957		// referenced from field958		eval!(959			r#"{960				local me = self,961				a: 3,962				b: me.a,963			}.b"#964		);965	}966967	// We can't trust other tests (And official jsonnet testsuite), if assert is not working correctly968	#[test]969	fn std_assert_ok() {970		eval!("std.assertEqual(4.5 << 2, 16)");971	}972973	#[test]974	#[should_panic]975	fn std_assert_failure() {976		eval!("std.assertEqual(4.5 << 2, 15)");977	}978979	#[test]980	fn string_is_string() {981		assert!(primitive_equals(982			&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),983			&Val::Bool(false),984		)985		.unwrap());986	}987988	#[test]989	fn base64_works() {990		assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);991	}992993	#[test]994	fn utf8_chars() {995		assert_json!(996			r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,997			r#"{"c": 128526,"l": 1}"#998		)999	}10001001	#[test]1002	fn json() {1003		assert_json!(1004			r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,1005			r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#1006		);1007	}10081009	#[test]1010	fn json_minified() {1011		assert_json!(1012			r#"std.manifestJsonMinified({a:3, b:4, c:6})"#,1013			r#""{\"a\":3,\"b\":4,\"c\":6}""#1014		);1015	}10161017	#[test]1018	fn parse_json() {1019		assert_json!(1020			r#"std.parseJson('{"a": -1,"b": 1,"c": 3.141,"d": []}')"#,1021			r#"{"a": -1,"b": 1,"c": 3.141,"d": []}"#1022		);1023	}10241025	#[test]1026	fn test() {1027		assert_json!(1028			r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,1029			"[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"1030		);1031	}10321033	#[test]1034	fn sjsonnet() {1035		eval!(1036			r#"1037			local x0 = {k: 1};1038			local x1 = {k: x0.k + x0.k};1039			local x2 = {k: x1.k + x1.k};1040			local x3 = {k: x2.k + x2.k};1041			local x4 = {k: x3.k + x3.k};1042			local x5 = {k: x4.k + x4.k};1043			local x6 = {k: x5.k + x5.k};1044			local x7 = {k: x6.k + x6.k};1045			local x8 = {k: x7.k + x7.k};1046			local x9 = {k: x8.k + x8.k};1047			local x10 = {k: x9.k + x9.k};1048			local x11 = {k: x10.k + x10.k};1049			local x12 = {k: x11.k + x11.k};1050			local x13 = {k: x12.k + x12.k};1051			local x14 = {k: x13.k + x13.k};1052			local x15 = {k: x14.k + x14.k};1053			local x16 = {k: x15.k + x15.k};1054			local x17 = {k: x16.k + x16.k};1055			local x18 = {k: x17.k + x17.k};1056			local x19 = {k: x18.k + x18.k};1057			local x20 = {k: x19.k + x19.k};1058			local x21 = {k: x20.k + x20.k};1059			x21.k1060		"#1061		);1062	}10631064	// This test is commented out by default, because of huge compilation slowdown1065	// #[bench]1066	// fn bench_codegen(b: &mut Bencher) {1067	// 	b.iter(|| {1068	// 		#[allow(clippy::all)]1069	// 		let stdlib = {1070	// 			use jrsonnet_parser::*;1071	// 			include!(concat!(env!("OUT_DIR"), "/stdlib.rs"))1072	// 		};1073	// 		stdlib1074	// 	})1075	// }10761077	/*1078	#[bench]1079	fn bench_serialize(b: &mut Bencher) {1080		b.iter(|| {1081			bincode::deserialize::<jrsonnet_parser::LocExpr>(include_bytes!(concat!(1082				env!("OUT_DIR"),1083				"/stdlib.bincode"1084			)))1085			.expect("deserialize stdlib")1086		})1087	}10881089	#[bench]1090	fn bench_parse(b: &mut Bencher) {1091		b.iter(|| {1092			jrsonnet_parser::parse(1093				jrsonnet_stdlib::STDLIB_STR,1094				&jrsonnet_parser::ParserSettings {1095					loc_data: true,1096					file_name: Rc::new(PathBuf::from("std.jsonnet")),1097				},1098			)1099		})1100	}1101	*/11021103	#[test]1104	fn equality() {1105		println!(1106			"{:?}",1107			jrsonnet_parser::parse(1108				"{ x: 1, y: 2 } == { x: 1, y: 2 }",1109				&ParserSettings {1110					file_name: PathBuf::from("equality").into(),1111				}1112			)1113		);1114		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")1115	}11161117	#[test]1118	fn native_ext() -> crate::error::Result<()> {1119		use super::native::NativeCallback;1120		let evaluator = EvaluationState::default();11211122		evaluator.with_stdlib();11231124		#[derive(Trace)]1125		struct NativeAdd;1126		impl NativeCallbackHandler for NativeAdd {1127			fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {1128				assert_eq!(1129					&from.unwrap() as &Path,1130					&PathBuf::from("native_caller.jsonnet")1131				);1132				match (&args[0], &args[1]) {1133					(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),1134					(_, _) => unreachable!(),1135				}1136			}1137		}1138		evaluator.settings_mut().ext_natives.insert(1139			"native_add".into(),1140			#[allow(deprecated)]1141			Cc::new(TraceBox(Box::new(NativeCallback::new(1142				vec![1143					BuiltinParam {1144						name: "a".into(),1145						has_default: false,1146					},1147					BuiltinParam {1148						name: "b".into(),1149						has_default: false,1150					},1151				],1152				TraceBox(Box::new(NativeAdd)),1153			)))),1154		);1155		evaluator.evaluate_snippet_raw(1156			PathBuf::from("native_caller.jsonnet").into(),1157			"std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),1158		)?;1159		Ok(())1160	}11611162	#[test]1163	fn constant_intrinsic() -> crate::error::Result<()> {1164		assert_eval!(1165			"local std2 = std; local std = std2 { primitiveEquals(a, b):: false }; 1 == 1"1166		);1167		Ok(())1168	}11691170	#[test]1171	fn standalone_super() -> crate::error::Result<()> {1172		assert_eval!(1173			r#"1174			local obj = {1175				a: 1,1176				b: 2,1177				c: 3,1178			};1179			local test = obj + {1180				fields: std.objectFields(super),1181				d: 5,1182			};1183			test.fields == ['a', 'b', 'c']1184		"#1185		);1186		Ok(())1187	}11881189	#[test]1190	fn comp_self() -> crate::error::Result<()> {1191		assert_eval!(1192			r#"1193			std.objectFields({1194				a:{1195					[name]: name for name in std.objectFields(self)1196				},1197				b: 2,1198				c: 3,1199			}.a) == ['a', 'b', 'c']1200			"#1201		);12021203		Ok(())1204	}12051206	struct TestImportResolver(IStr);1207	impl crate::import::ImportResolver for TestImportResolver {1208		fn resolve_file(&self, _: &Path, _: &Path) -> crate::error::Result<Rc<Path>> {1209			Ok(PathBuf::from("/test").into())1210		}12111212		fn load_file_contents(&self, _: &Path) -> crate::error::Result<IStr> {1213			Ok(self.0.clone())1214		}12151216		unsafe fn as_any(&self) -> &dyn std::any::Any {1217			panic!()1218		}1219	}12201221	#[test]1222	fn issue_23() {1223		let state = EvaluationState::default();1224		state.set_import_resolver(Box::new(TestImportResolver(r#"import "/test""#.into())));1225		let _ = state.evaluate_file_raw(&PathBuf::from("/test"));1226	}12271228	#[test]1229	fn issue_40() {1230		let state = EvaluationState::default();1231		state.with_stdlib();12321233		let error = state1234			.evaluate_snippet_raw(1235				PathBuf::from("issue40.jsonnet").into(),1236				r#"1237				local conf = {1238					n: ""1239				};12401241				local result = conf + {1242					assert std.isNumber(self.n): "is number"1243				};12441245				std.manifestJsonEx(result, "")1246			"#1247				.into(),1248			)1249			.unwrap_err();1250		assert_eq!(error.error().to_string(), "assert failed: is number");1251	}12521253	#[test]1254	fn test_ascii_upper_lower() {1255		assert_eval!(r#"std.assertEqual(std.asciiUpper("aBc😀"), "ABC😀")"#);1256		assert_eval!(r#"std.assertEqual(std.asciiLower("aBc😀"), "abc😀")"#);1257	}12581259	#[test]1260	fn test_member() {1261		assert_eval!(r#"!std.member("", "")"#);1262		assert_eval!(r#"std.member("abc", "a")"#);1263		assert_eval!(r#"!std.member("abc", "d")"#);1264		assert_eval!(r#"!std.member([], "")"#);1265		assert_eval!(r#"std.member(["a", "b", "c"], "a")"#);1266		assert_eval!(r#"!std.member(["a", "b", "c"], "d")"#);1267	}12681269	#[test]1270	fn test_count() {1271		assert_eval!(r#"std.assertEqual(std.count([], ""), 0)"#);1272		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "d"), 0)"#);1273		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "a"), 2)"#);1274	}12751276	mod derive_typed {1277		use crate::{typed::Typed, EvaluationState};1278		use std::path::PathBuf;12791280		#[derive(Typed, PartialEq, Debug)]1281		struct MyTyped {1282			a: u32,1283			#[typed(rename = "b")]1284			c: String,1285		}12861287		#[test]1288		fn test() {1289			let es = EvaluationState::default();1290			let val = eval!("{a: 14, b: 'Hello, world!'}");1291			let typed = es.run_in_state(|| MyTyped::try_from(val).unwrap());12921293			assert_eq!(1294				typed,1295				MyTyped {1296					a: 14,1297					c: "Hello, world!".to_string()1298				}1299			);1300			es.settings_mut().globals.insert(1301				"mytyped".into(),1302				es.run_in_state(|| typed.try_into()).unwrap(),1303			);13041305			let v = es1306				.evaluate_snippet_raw(1307					PathBuf::from("raw.jsonnet").into(),1308					"1309				mytyped == {a: 14, b: 'Hello, world!'}1310			"1311					.into(),1312				)1313				.unwrap()1314				.as_bool()1315				.unwrap();1316			assert!(v)1317		}1318	}1319}