git.delta.rocks / jrsonnet / refs/commits / 11643ec5f009

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;16pub mod gc;17mod import;18mod integrations;19mod map;20pub mod native;21mod obj;22pub mod trace;23pub mod typed;24pub mod val;2526use std::{27	cell::{Ref, RefCell, RefMut},28	collections::HashMap,29	fmt::Debug,30	path::{Path, PathBuf},31	rc::Rc,32};3334pub use ctx::*;35pub use dynamic::*;36use error::{Error::*, LocError, Result, StackTraceElement};37pub use evaluate::*;38use function::{Builtin, CallLocation, TlaArg};39use gc::{GcHashMap, TraceBox};40use gcmodule::{Cc, Trace, Weak};41pub use import::*;42pub use jrsonnet_interner::IStr;43pub use jrsonnet_parser as parser;44use jrsonnet_parser::*;45pub use obj::*;46use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};47pub use val::{LazyVal, ManifestFormat, Val};4849pub trait Bindable: Trace + 'static {50	fn bind(51		&self,52		s: State,53		this: Option<ObjValue>,54		super_obj: Option<ObjValue>,55	) -> Result<LazyVal>;56}5758#[derive(Clone, Trace)]59pub enum LazyBinding {60	Bindable(Cc<TraceBox<dyn Bindable>>),61	Bound(LazyVal),62}6364impl Debug for LazyBinding {65	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {66		write!(f, "LazyBinding")67	}68}69impl LazyBinding {70	pub fn evaluate(71		&self,72		s: State,73		this: Option<ObjValue>,74		super_obj: Option<ObjValue>,75	) -> Result<LazyVal> {76		match self {77			Self::Bindable(v) => v.bind(s, this, super_obj),78			Self::Bound(v) => Ok(v.clone()),79		}80	}81}8283pub struct EvaluationSettings {84	/// Limits recursion by limiting the number of stack frames85	pub max_stack: usize,86	/// Limits amount of stack trace items preserved87	pub max_trace: usize,88	/// Used for s`td.extVar`89	pub ext_vars: HashMap<IStr, Val>,90	/// Used for ext.native91	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,92	/// TLA vars93	pub tla_vars: HashMap<IStr, TlaArg>,94	/// Global variables are inserted in default context95	pub globals: HashMap<IStr, Val>,96	/// Used to resolve file locations/contents97	pub import_resolver: Box<dyn ImportResolver>,98	/// Used in manifestification functions99	pub manifest_format: ManifestFormat,100	/// Used for bindings101	pub trace_format: Box<dyn TraceFormat>,102}103impl Default for EvaluationSettings {104	fn default() -> Self {105		Self {106			max_stack: 200,107			max_trace: 20,108			globals: Default::default(),109			ext_vars: Default::default(),110			ext_natives: Default::default(),111			tla_vars: Default::default(),112			import_resolver: Box::new(DummyImportResolver),113			manifest_format: ManifestFormat::Json {114				padding: 4,115				#[cfg(feature = "exp-preserve-order")]116				preserve_order: false,117			},118			trace_format: Box::new(CompactFormat {119				padding: 4,120				resolver: trace::PathResolver::Absolute,121			}),122		}123	}124}125126#[derive(Default)]127struct EvaluationData {128	/// Used for stack overflow detection, stacktrace is populated on unwind129	stack_depth: usize,130	/// Updated every time stack entry is popt131	stack_generation: usize,132133	breakpoints: Breakpoints,134	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces135	files: GcHashMap<Rc<Path>, FileData>,136	str_files: GcHashMap<Rc<Path>, IStr>,137	bin_files: GcHashMap<Rc<Path>, Rc<[u8]>>,138}139140pub struct FileData {141	source_code: IStr,142	parsed: LocExpr,143	evaluated: Option<Val>,144}145146#[allow(clippy::type_complexity)]147pub struct Breakpoint {148	loc: ExprLocation,149	collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,150}151#[derive(Default)]152struct Breakpoints(Vec<Rc<Breakpoint>>);153impl Breakpoints {154	fn insert(155		&self,156		stack_depth: usize,157		stack_generation: usize,158		loc: &ExprLocation,159		result: Result<Val>,160	) -> Result<Val> {161		if self.0.is_empty() {162			return result;163		}164		for item in self.0.iter() {165			if item.loc.belongs_to(loc) {166				let mut collected = item.collected.borrow_mut();167				let (depth, vals) = collected.entry(stack_generation).or_default();168				if stack_depth > *depth {169					vals.clear();170				}171				vals.push(result.clone());172			}173		}174		result175	}176}177178#[derive(Default)]179pub struct EvaluationStateInternals {180	/// Internal state181	data: RefCell<EvaluationData>,182	/// Settings, safe to change at runtime183	settings: RefCell<EvaluationSettings>,184}185186/// Maintains stack trace and import resolution187#[derive(Default, Clone)]188pub struct State(Rc<EvaluationStateInternals>);189190impl State {191	/// Parses and adds file as loaded192	pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {193		let parsed = parse(194			&source_code,195			&ParserSettings {196				file_name: path.clone(),197			},198		)199		.map_err(|error| ImportSyntaxError {200			error: Box::new(error),201			path: path.to_owned(),202			source_code: source_code.clone(),203		})?;204		self.add_parsed_file(path, source_code, parsed.clone())?;205206		Ok(parsed)207	}208209	pub fn reset_evaluation_state(&self, name: &Path) {210		self.data_mut()211			.files212			.get_mut(name)213			.unwrap()214			.evaluated215			.take();216	}217218	/// Adds file by source code and parsed expr219	pub fn add_parsed_file(220		&self,221		name: Rc<Path>,222		source_code: IStr,223		parsed: LocExpr,224	) -> Result<()> {225		self.data_mut().files.insert(226			name,227			FileData {228				source_code,229				parsed,230				evaluated: None,231			},232		);233234		Ok(())235	}236	pub fn get_source(&self, name: &Path) -> Option<IStr> {237		let ro_map = &self.data().files;238		ro_map.get(name).map(|value| value.source_code.clone())239	}240	pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {241		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)242	}243	pub fn map_from_source_location(244		&self,245		file: &Path,246		line: usize,247		column: usize,248	) -> Option<usize> {249		location_to_offset(&self.get_source(file).unwrap(), line, column)250	}251	pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {252		let file_path = self.resolve_file(from, path)?;253		{254			let data = self.data();255			let files = &data.files;256			if files.contains_key(&file_path as &Path) {257				drop(data);258				return self.evaluate_loaded_file_raw(&file_path);259			}260		}261		let contents = self.load_file_str(&file_path)?;262		self.add_file(file_path.clone(), contents)?;263		self.evaluate_loaded_file_raw(&file_path)264	}265	pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {266		let path = self.resolve_file(from, path)?;267		if !self.data().str_files.contains_key(&path) {268			let file_str = self.load_file_str(&path)?;269			self.data_mut().str_files.insert(path.clone(), file_str);270		}271		Ok(self.data().str_files.get(&path).cloned().unwrap())272	}273	pub(crate) fn import_file_bin(&self, from: &Path, path: &Path) -> Result<Rc<[u8]>> {274		let path = self.resolve_file(from, path)?;275		if !self.data().bin_files.contains_key(&path) {276			let file_bin = self.load_file_bin(&path)?;277			self.data_mut().bin_files.insert(path.clone(), file_bin);278		}279		Ok(self.data().bin_files.get(&path).cloned().unwrap())280	}281282	fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {283		let expr: LocExpr = {284			let ro_map = &self.data().files;285			let value = ro_map286				.get(name)287				.unwrap_or_else(|| panic!("file not added: {:?}", name));288			if let Some(ref evaluated) = value.evaluated {289				return Ok(evaluated.clone());290			}291			value.parsed.clone()292		};293		let value = evaluate(self.clone(), self.create_default_context(), &expr)?;294		{295			self.data_mut()296				.files297				.get_mut(name)298				.unwrap()299				.evaluated300				.replace(value.clone());301		}302		Ok(value)303	}304305	/// Adds standard library global variable (std) to this evaluator306	pub fn with_stdlib(&self) -> &Self {307		use jrsonnet_stdlib::STDLIB_STR;308		let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();309310		self.add_parsed_file(311			std_path.clone(),312			STDLIB_STR.to_owned().into(),313			builtin::get_parsed_stdlib(),314		)315		.unwrap();316		let val = self.evaluate_loaded_file_raw(&std_path).unwrap();317		self.settings_mut().globals.insert("std".into(), val);318		self319	}320321	/// Creates context with all passed global variables322	pub fn create_default_context(&self) -> Context {323		let globals = &self.settings().globals;324		let mut new_bindings = GcHashMap::with_capacity(globals.len());325		for (name, value) in globals.iter() {326			new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));327		}328		Context::new().extend_bound(new_bindings)329	}330331	/// Executes code creating a new stack frame332	pub fn push<T>(333		&self,334		e: CallLocation,335		frame_desc: impl FnOnce() -> String,336		f: impl FnOnce() -> Result<T>,337	) -> Result<T> {338		{339			let mut data = self.data_mut();340			let stack_depth = &mut data.stack_depth;341			if *stack_depth > self.max_stack() {342				// Error creation uses data, so i drop guard here343				drop(data);344				throw!(StackOverflow);345			} else {346				*stack_depth += 1;347			}348		}349		let result = f();350		{351			let mut data = self.data_mut();352			data.stack_depth -= 1;353			data.stack_generation += 1;354		}355		if let Err(mut err) = result {356			err.trace_mut().0.push(StackTraceElement {357				location: e.0.cloned(),358				desc: frame_desc(),359			});360			return Err(err);361		}362		result363	}364365	/// Executes code creating a new stack frame366	pub fn push_val(367		&self,368		e: &ExprLocation,369		frame_desc: impl FnOnce() -> String,370		f: impl FnOnce() -> Result<Val>,371	) -> Result<Val> {372		{373			let mut data = self.data_mut();374			let stack_depth = &mut data.stack_depth;375			if *stack_depth > self.max_stack() {376				// Error creation uses data, so i drop guard here377				drop(data);378				throw!(StackOverflow);379			} else {380				*stack_depth += 1;381			}382		}383		let mut result = f();384		{385			let mut data = self.data_mut();386			data.stack_depth -= 1;387			data.stack_generation += 1;388			result = data389				.breakpoints390				.insert(data.stack_depth, data.stack_generation, e, result);391		}392		if let Err(mut err) = result {393			err.trace_mut().0.push(StackTraceElement {394				location: Some(e.clone()),395				desc: frame_desc(),396			});397			return Err(err);398		}399		result400	}401	/// Executes code creating a new stack frame402	pub fn push_description<T>(403		&self,404		frame_desc: impl FnOnce() -> String,405		f: impl FnOnce() -> Result<T>,406	) -> Result<T> {407		{408			let mut data = self.data_mut();409			let stack_depth = &mut data.stack_depth;410			if *stack_depth > self.max_stack() {411				// Error creation uses data, so i drop guard here412				drop(data);413				throw!(StackOverflow);414			} else {415				*stack_depth += 1;416			}417		}418		let result = f();419		{420			let mut data = self.data_mut();421			data.stack_depth -= 1;422			data.stack_generation += 1;423		}424		if let Err(mut err) = result {425			err.trace_mut().0.push(StackTraceElement {426				location: None,427				desc: frame_desc(),428			});429			return Err(err);430		}431		result432	}433434	pub fn stringify_err(&self, e: &LocError) -> String {435		let mut out = String::new();436		self.settings()437			.trace_format438			.write_trace(&mut out, self, e)439			.unwrap();440		out441	}442443	pub fn manifest(&self, val: Val) -> Result<IStr> {444		self.push_description(445			|| "manifestification".to_string(),446			|| val.manifest(self.clone(), &self.manifest_format()),447		)448	}449	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {450		val.manifest_multi(self.clone(), &self.manifest_format())451	}452	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {453		val.manifest_stream(self.clone(), &self.manifest_format())454	}455456	/// If passed value is function then call with set TLA457	pub fn with_tla(&self, val: Val) -> Result<Val> {458		Ok(match val {459			Val::Func(func) => self.push_description(460				|| "during TLA call".to_owned(),461				|| {462					func.evaluate(463						self.clone(),464						self.create_default_context(),465						CallLocation::native(),466						&self.settings().tla_vars,467						true,468					)469				},470			)?,471			v => v,472		})473	}474}475476/// Internals477impl State {478	fn data(&self) -> Ref<EvaluationData> {479		self.0.data.borrow()480	}481	fn data_mut(&self) -> RefMut<EvaluationData> {482		self.0.data.borrow_mut()483	}484	pub fn settings(&self) -> Ref<EvaluationSettings> {485		self.0.settings.borrow()486	}487	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {488		self.0.settings.borrow_mut()489	}490}491492/// Raw methods evaluate passed values but don't perform TLA execution493impl State {494	pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {495		self.import_file(&std::env::current_dir().expect("cwd"), name)496	}497	pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {498		self.import_file(&PathBuf::from("."), name)499	}500	/// Parses and evaluates the given snippet501	pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {502		let parsed = parse(503			&code,504			&ParserSettings {505				file_name: source.clone(),506			},507		)508		.map_err(|e| ImportSyntaxError {509			path: source.clone(),510			source_code: code.clone(),511			error: Box::new(e),512		})?;513		self.add_parsed_file(source, code, parsed.clone())?;514		self.evaluate_expr_raw(parsed)515	}516	/// Evaluates the parsed expression517	pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {518		evaluate(self.clone(), self.create_default_context(), &code)519	}520}521522/// Settings utilities523impl State {524	pub fn add_ext_var(&self, name: IStr, value: Val) {525		self.settings_mut().ext_vars.insert(name, value);526	}527	pub fn add_ext_str(&self, name: IStr, value: IStr) {528		self.add_ext_var(name, Val::Str(value));529	}530	pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {531		let value =532			self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;533		self.add_ext_var(name, value);534		Ok(())535	}536537	pub fn add_tla(&self, name: IStr, value: Val) {538		self.settings_mut()539			.tla_vars540			.insert(name, TlaArg::Val(value));541	}542	pub fn add_tla_str(&self, name: IStr, value: IStr) {543		self.settings_mut()544			.tla_vars545			.insert(name, TlaArg::String(value));546	}547	pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {548		let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;549		self.settings_mut()550			.tla_vars551			.insert(name, TlaArg::Code(parsed));552		Ok(())553	}554555	pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {556		self.settings().import_resolver.resolve_file(from, path)557	}558	pub fn load_file_str(&self, path: &Path) -> Result<IStr> {559		self.settings().import_resolver.load_file_str(path)560	}561	pub fn load_file_bin(&self, path: &Path) -> Result<Rc<[u8]>> {562		self.settings().import_resolver.load_file_bin(path)563	}564565	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {566		Ref::map(self.settings(), |s| &*s.import_resolver)567	}568	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {569		self.settings_mut().import_resolver = resolver;570	}571572	pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {573		self.settings_mut().ext_natives.insert(name, cb);574	}575576	pub fn manifest_format(&self) -> ManifestFormat {577		self.settings().manifest_format.clone()578	}579	pub fn set_manifest_format(&self, format: ManifestFormat) {580		self.settings_mut().manifest_format = format;581	}582583	pub fn trace_format(&self) -> Ref<dyn TraceFormat> {584		Ref::map(self.settings(), |s| &*s.trace_format)585	}586	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {587		self.settings_mut().trace_format = format;588	}589590	pub fn max_trace(&self) -> usize {591		self.settings().max_trace592	}593	pub fn set_max_trace(&self, trace: usize) {594		self.settings_mut().max_trace = trace;595	}596597	pub fn max_stack(&self) -> usize {598		self.settings().max_stack599	}600	pub fn set_max_stack(&self, trace: usize) {601		self.settings_mut().max_stack = trace;602	}603}604605pub fn cc_ptr_eq<T>(a: &Cc<T>, b: &Cc<T>) -> bool {606	let a = a as &T;607	let b = b as &T;608	std::ptr::eq(a, b)609}610611fn weak_raw<T>(a: Weak<T>) -> *const () {612	unsafe { std::mem::transmute(a) }613}614fn weak_ptr_eq<T>(a: Weak<T>, b: Weak<T>) -> bool {615	std::ptr::eq(weak_raw(a), weak_raw(b))616}617618#[test]619fn weak_unsafe() {620	let a = Cc::new(1);621	let b = Cc::new(2);622623	let aw1 = a.clone().downgrade();624	let aw2 = a.clone().downgrade();625	let aw3 = a.clone().downgrade();626627	let bw = b.clone().downgrade();628629	assert!(weak_ptr_eq(aw1, aw2));630	assert!(!weak_ptr_eq(aw3, bw));631}632633#[cfg(test)]634pub mod tests {635	use std::{636		path::{Path, PathBuf},637		rc::Rc,638	};639640	use gcmodule::{Cc, Trace};641	use jrsonnet_parser::*;642643	use super::Val;644	use crate::{645		error::Error::*,646		function::{BuiltinParam, CallLocation},647		gc::TraceBox,648		native::NativeCallbackHandler,649		val::primitive_equals,650		State,651	};652653	#[test]654	#[should_panic]655	fn eval_state_stacktrace() {656		let state = State::default();657		state658			.push(659				CallLocation::new(&ExprLocation(PathBuf::from("test1.jsonnet").into(), 10, 20)),660				|| "outer".to_owned(),661				|| {662					state.push(663						CallLocation::new(&ExprLocation(664							PathBuf::from("test2.jsonnet").into(),665							30,666							40,667						)),668						|| "inner".to_owned(),669						|| Err(RuntimeError("".into()).into()),670					)?;671					Ok(Val::Null)672				},673			)674			.unwrap();675	}676677	#[test]678	fn eval_state_standard() {679		let state = State::default();680		state.with_stdlib();681		assert!(primitive_equals(682			&state683				.evaluate_snippet_raw(684					PathBuf::from("raw.jsonnet").into(),685					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#.into()686				)687				.unwrap(),688			&Val::Bool(true),689		)690		.unwrap());691	}692693	macro_rules! eval {694		($str: expr) => {{695			let evaluator = State::default();696			evaluator.with_stdlib();697			evaluator698				.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())699				.unwrap()700		}};701	}702	macro_rules! eval_json {703		($str: expr) => {{704			let evaluator = State::default();705			evaluator.with_stdlib();706			evaluator707				.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())708				.unwrap()709				.to_json(0)710				.unwrap()711				.replace("\n", "")712		}};713	}714715	/// Asserts given code returns `true`716	macro_rules! assert_eval {717		($str: expr) => {718			assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())719		};720	}721722	/// Asserts given code returns `false`723	macro_rules! assert_eval_neg {724		($str: expr) => {725			assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())726		};727	}728	macro_rules! assert_json {729		($str: expr, $out: expr) => {730			assert_eq!(eval_json!($str), $out.replace("\t", ""))731		};732	}733734	/// Sanity checking, before trusting to another tests735	#[test]736	fn equality_operator() {737		assert_eval!("2 == 2");738		assert_eval_neg!("2 != 2");739		assert_eval!("2 != 3");740		assert_eval_neg!("2 == 3");741		assert_eval!("'Hello' == 'Hello'");742		assert_eval_neg!("'Hello' != 'Hello'");743		assert_eval!("'Hello' != 'World'");744		assert_eval_neg!("'Hello' == 'World'");745	}746747	#[test]748	fn math_evaluation() {749		assert_eval!("2 + 2 * 2 == 6");750		assert_eval!("3 + (2 + 2 * 2) == 9");751	}752753	#[test]754	fn string_concat() {755		assert_eval!("'Hello' + 'World' == 'HelloWorld'");756		assert_eval!("'Hello' * 3 == 'HelloHelloHello'");757		assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");758	}759760	#[test]761	fn faster_join() {762		assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");763		assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");764	}765766	#[test]767	fn function_contexts() {768		assert_eval!(769			r#"770				local k = {771					t(name = self.h): [self.h, name],772					h: 3,773				};774				local f = {775					t: k.t(),776					h: 4,777				};778				f.t[0] == f.t[1]779			"#780		);781	}782783	#[test]784	fn local() {785		assert_eval!("local a = 2; local b = 3; a + b == 5");786		assert_eval!("local a = 1, b = a + 1; a + b == 3");787		assert_eval!("local a = 1; local a = 2; a == 2");788	}789790	#[test]791	fn object_lazyness() {792		assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);793	}794795	#[test]796	fn object_inheritance() {797		assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);798	}799800	#[test]801	fn object_assertion_success() {802		eval!("{assert \"a\" in self} + {a:2}");803	}804805	#[test]806	fn object_assertion_error() {807		eval!("{assert \"a\" in self}");808	}809810	#[test]811	fn lazy_args() {812		eval!("local test(a) = 2; test(error '3')");813	}814815	#[test]816	#[should_panic]817	fn tailstrict_args() {818		eval!("local test(a) = 2; test(error '3') tailstrict");819	}820821	#[test]822	#[should_panic]823	fn no_binding_error() {824		eval!("a");825	}826827	#[test]828	fn test_object() {829		assert_json!("{a:2}", r#"{"a": 2}"#);830		assert_json!("{a:2+2}", r#"{"a": 4}"#);831		assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);832		assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);833		assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);834		assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);835		assert_json!(836			r#"837				{838					name: "Alice",839					welcome: "Hello " + self.name + "!",840				}841			"#,842			r#"{"name": "Alice","welcome": "Hello Alice!"}"#843		);844		assert_json!(845			r#"846				{847					name: "Alice",848					welcome: "Hello " + self.name + "!",849				} + {850					name: "Bob"851				}852			"#,853			r#"{"name": "Bob","welcome": "Hello Bob!"}"#854		);855	}856857	#[test]858	fn functions() {859		assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");860		assert_json!(861			r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,862			r#""HelloDearWorld""#863		);864	}865866	#[test]867	fn local_methods() {868		assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");869		assert_json!(870			r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,871			r#""HelloDearWorld""#872		);873	}874875	#[test]876	fn object_locals() {877		assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);878		assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);879		assert_json!(880			r#"{local a = function (b) {[b]:4}, test: a("test")}"#,881			r#"{"test": {"test": 4}}"#882		);883	}884885	#[test]886	fn object_comp() {887		assert_json!(888			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}"#,889			"{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"890		)891	}892893	#[test]894	fn direct_self() {895		println!(896			"{:#?}",897			eval!(898				r#"899					{900						local me = self,901						a: 3,902						b(): me.a,903					}904				"#905			)906		);907	}908909	#[test]910	fn indirect_self() {911		// `self` assigned to `me` was lost when being912		// referenced from field913		eval!(914			r#"{915				local me = self,916				a: 3,917				b: me.a,918			}.b"#919		);920	}921922	// We can't trust other tests (And official jsonnet testsuite), if assert is not working correctly923	#[test]924	fn std_assert_ok() {925		eval!("std.assertEqual(4.5 << 2, 16)");926	}927928	#[test]929	#[should_panic]930	fn std_assert_failure() {931		eval!("std.assertEqual(4.5 << 2, 15)");932	}933934	#[test]935	fn string_is_string() {936		assert!(primitive_equals(937			&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),938			&Val::Bool(false),939		)940		.unwrap());941	}942943	#[test]944	fn base64_works() {945		assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);946	}947948	#[test]949	fn utf8_chars() {950		assert_json!(951			r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,952			r#"{"c": 128526,"l": 1}"#953		)954	}955956	#[test]957	fn json() {958		assert_json!(959			r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,960			r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#961		);962	}963964	#[test]965	fn json_minified() {966		assert_json!(967			r#"std.manifestJsonMinified({a:3, b:4, c:6})"#,968			r#""{\"a\":3,\"b\":4,\"c\":6}""#969		);970	}971972	#[test]973	fn parse_json() {974		assert_json!(975			r#"std.parseJson('{"a": -1,"b": 1,"c": 3.141,"d": []}')"#,976			r#"{"a": -1,"b": 1,"c": 3.141,"d": []}"#977		);978	}979980	#[test]981	fn test() {982		assert_json!(983			r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,984			"[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"985		);986	}987988	#[test]989	fn sjsonnet() {990		eval!(991			r#"992			local x0 = {k: 1};993			local x1 = {k: x0.k + x0.k};994			local x2 = {k: x1.k + x1.k};995			local x3 = {k: x2.k + x2.k};996			local x4 = {k: x3.k + x3.k};997			local x5 = {k: x4.k + x4.k};998			local x6 = {k: x5.k + x5.k};999			local x7 = {k: x6.k + x6.k};1000			local x8 = {k: x7.k + x7.k};1001			local x9 = {k: x8.k + x8.k};1002			local x10 = {k: x9.k + x9.k};1003			local x11 = {k: x10.k + x10.k};1004			local x12 = {k: x11.k + x11.k};1005			local x13 = {k: x12.k + x12.k};1006			local x14 = {k: x13.k + x13.k};1007			local x15 = {k: x14.k + x14.k};1008			local x16 = {k: x15.k + x15.k};1009			local x17 = {k: x16.k + x16.k};1010			local x18 = {k: x17.k + x17.k};1011			local x19 = {k: x18.k + x18.k};1012			local x20 = {k: x19.k + x19.k};1013			local x21 = {k: x20.k + x20.k};1014			x21.k1015		"#1016		);1017	}10181019	// This test is commented out by default, because of huge compilation slowdown1020	// #[bench]1021	// fn bench_codegen(b: &mut Bencher) {1022	// 	b.iter(|| {1023	// 		#[allow(clippy::all)]1024	// 		let stdlib = {1025	// 			use jrsonnet_parser::*;1026	// 			include!(concat!(env!("OUT_DIR"), "/stdlib.rs"))1027	// 		};1028	// 		stdlib1029	// 	})1030	// }10311032	/*1033	#[bench]1034	fn bench_serialize(b: &mut Bencher) {1035		b.iter(|| {1036			bincode::deserialize::<jrsonnet_parser::LocExpr>(include_bytes!(concat!(1037				env!("OUT_DIR"),1038				"/stdlib.bincode"1039			)))1040			.expect("deserialize stdlib")1041		})1042	}10431044	#[bench]1045	fn bench_parse(b: &mut Bencher) {1046		b.iter(|| {1047			jrsonnet_parser::parse(1048				jrsonnet_stdlib::STDLIB_STR,1049				&jrsonnet_parser::ParserSettings {1050					loc_data: true,1051					file_name: Rc::new(PathBuf::from("std.jsonnet")),1052				},1053			)1054		})1055	}1056	*/10571058	#[test]1059	fn equality() {1060		println!(1061			"{:?}",1062			jrsonnet_parser::parse(1063				"{ x: 1, y: 2 } == { x: 1, y: 2 }",1064				&ParserSettings {1065					file_name: PathBuf::from("equality").into(),1066				}1067			)1068		);1069		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")1070	}10711072	#[test]1073	fn native_ext() -> crate::error::Result<()> {1074		use super::native::NativeCallback;1075		let evaluator = State::default();10761077		evaluator.with_stdlib();10781079		#[derive(Trace)]1080		struct NativeAdd;1081		impl NativeCallbackHandler for NativeAdd {1082			fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {1083				assert_eq!(1084					&from.unwrap() as &Path,1085					&PathBuf::from("native_caller.jsonnet")1086				);1087				match (&args[0], &args[1]) {1088					(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),1089					(_, _) => unreachable!(),1090				}1091			}1092		}1093		evaluator.settings_mut().ext_natives.insert(1094			"native_add".into(),1095			#[allow(deprecated)]1096			Cc::new(TraceBox(Box::new(NativeCallback::new(1097				vec![1098					BuiltinParam {1099						name: "a".into(),1100						has_default: false,1101					},1102					BuiltinParam {1103						name: "b".into(),1104						has_default: false,1105					},1106				],1107				TraceBox(Box::new(NativeAdd)),1108			)))),1109		);1110		dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1111		evaluator.evaluate_snippet_raw(1112			PathBuf::from("native_caller.jsonnet").into(),1113			"std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),1114		)?;1115		dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1116		Ok(())1117	}11181119	#[test]1120	fn constant_intrinsic() -> crate::error::Result<()> {1121		assert_eval!(1122			"local std2 = std; local std = std2 { primitiveEquals(a, b):: false }; 1 == 1"1123		);1124		Ok(())1125	}11261127	#[test]1128	fn standalone_super() -> crate::error::Result<()> {1129		assert_eval!(1130			r#"1131			local obj = {1132				a: 1,1133				b: 2,1134				c: 3,1135			};1136			local test = obj + {1137				fields: std.objectFields(super),1138				d: 5,1139			};1140			test.fields == ['a', 'b', 'c']1141		"#1142		);1143		Ok(())1144	}11451146	#[test]1147	fn comp_self() -> crate::error::Result<()> {1148		assert_eval!(1149			r#"1150			std.objectFields({1151				a:{1152					[name]: name for name in std.objectFields(self)1153				},1154				b: 2,1155				c: 3,1156			}.a) == ['a', 'b', 'c']1157			"#1158		);11591160		Ok(())1161	}11621163	struct TestImportResolver(Vec<u8>);1164	impl crate::import::ImportResolver for TestImportResolver {1165		fn resolve_file(&self, _: &Path, _: &Path) -> crate::error::Result<Rc<Path>> {1166			Ok(PathBuf::from("/test").into())1167		}11681169		fn load_file_contents(&self, _: &Path) -> crate::error::Result<Vec<u8>> {1170			Ok(self.0.clone())1171		}11721173		unsafe fn as_any(&self) -> &dyn std::any::Any {1174			panic!()1175		}11761177		fn load_file_bin(&self, _resolved: &Path) -> crate::error::Result<Rc<[u8]>> {1178			panic!()1179		}1180	}11811182	#[test]1183	fn issue_23() {1184		let state = State::default();1185		state.set_import_resolver(Box::new(TestImportResolver(r#"import "/test""#.into())));1186		let _ = state.evaluate_file_raw(&PathBuf::from("/test"));1187	}11881189	#[test]1190	fn issue_40() {1191		let state = State::default();1192		state.with_stdlib();11931194		let error = state1195			.evaluate_snippet_raw(1196				PathBuf::from("issue40.jsonnet").into(),1197				r#"1198				local conf = {1199					n: ""1200				};12011202				local result = conf + {1203					assert std.isNumber(self.n): "is number"1204				};12051206				std.manifestJsonEx(result, "")1207			"#1208				.into(),1209			)1210			.unwrap_err();1211		assert_eq!(error.error().to_string(), "assert failed: is number");1212	}12131214	#[test]1215	fn test_ascii_upper_lower() {1216		assert_eval!(r#"std.assertEqual(std.asciiUpper("aBc😀"), "ABC😀")"#);1217		assert_eval!(r#"std.assertEqual(std.asciiLower("aBc😀"), "abc😀")"#);1218	}12191220	#[test]1221	fn test_member() {1222		assert_eval!(r#"!std.member("", "")"#);1223		assert_eval!(r#"std.member("abc", "a")"#);1224		assert_eval!(r#"!std.member("abc", "d")"#);1225		assert_eval!(r#"!std.member([], "")"#);1226		assert_eval!(r#"std.member(["a", "b", "c"], "a")"#);1227		assert_eval!(r#"!std.member(["a", "b", "c"], "d")"#);1228	}12291230	#[test]1231	fn test_count() {1232		assert_eval!(r#"std.assertEqual(std.count([], ""), 0)"#);1233		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "d"), 0)"#);1234		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "a"), 2)"#);1235	}12361237	mod derive_typed {1238		use std::path::PathBuf;12391240		use crate::{typed::Typed, State};12411242		#[derive(PartialEq, Debug, Typed)]1243		struct MyTyped {1244			a: u32,1245			#[typed(rename = "b")]1246			c: String,1247		}12481249		#[test]1250		fn test() {1251			let es = State::default();1252			let val = eval!("{a: 14, b: 'Hello, world!'}");1253			let typed = MyTyped::try_from(val).unwrap();12541255			assert_eq!(1256				typed,1257				MyTyped {1258					a: 14,1259					c: "Hello, world!".to_string()1260				}1261			);1262			es.settings_mut()1263				.globals1264				.insert("mytyped".into(), typed.try_into().unwrap());12651266			let v = es1267				.evaluate_snippet_raw(1268					PathBuf::from("raw.jsonnet").into(),1269					"1270				mytyped == {a: 14, b: 'Hello, world!'}1271			"1272					.into(),1273				)1274				.unwrap()1275				.as_bool()1276				.unwrap();1277			assert!(v)1278		}1279	}1280}