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

1#![warn(clippy::all, clippy::nursery, clippy::pedantic)]2#![allow(3	macro_expanded_macro_exports_accessed_by_absolute_paths,4	clippy::ptr_arg,5	// Too verbose6	clippy::must_use_candidate,7	// A lot of functions pass around errors thrown by code8	clippy::missing_errors_doc,9	// A lot of pointers have interior Rc10	clippy::needless_pass_by_value,11	// Its fine12	clippy::wildcard_imports,13	clippy::enum_glob_use,14	clippy::module_name_repetitions,15	// TODO: fix individual issues, however this works as intended almost everywhere16	clippy::cast_precision_loss,17	clippy::cast_possible_wrap,18	clippy::cast_possible_truncation,19	clippy::cast_sign_loss,20)]2122// For jrsonnet-macros23extern crate self as jrsonnet_evaluator;2425mod builtin;26mod ctx;27mod dynamic;28pub mod error;29mod evaluate;30pub mod function;31pub mod gc;32mod import;33mod integrations;34mod map;35pub mod native;36mod obj;37pub mod trace;38pub mod typed;39pub mod val;4041use std::{42	cell::{Ref, RefCell, RefMut},43	collections::HashMap,44	fmt::Debug,45	path::{Path, PathBuf},46	rc::Rc,47};4849pub use ctx::*;50pub use dynamic::*;51use error::{Error::*, LocError, Result, StackTraceElement};52pub use evaluate::*;53use function::{Builtin, CallLocation, TlaArg};54use gc::{GcHashMap, TraceBox};55use gcmodule::{Cc, Trace, Weak};56pub use import::*;57pub use jrsonnet_interner::IStr;58pub use jrsonnet_parser as parser;59use jrsonnet_parser::*;60pub use obj::*;61use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};62pub use val::{LazyVal, ManifestFormat, Val};6364pub trait Bindable: Trace + 'static {65	fn bind(66		&self,67		s: State,68		this: Option<ObjValue>,69		super_obj: Option<ObjValue>,70	) -> Result<LazyVal>;71}7273#[derive(Clone, Trace)]74pub enum LazyBinding {75	Bindable(Cc<TraceBox<dyn Bindable>>),76	Bound(LazyVal),77}7879impl Debug for LazyBinding {80	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {81		write!(f, "LazyBinding")82	}83}84impl LazyBinding {85	pub fn evaluate(86		&self,87		s: State,88		this: Option<ObjValue>,89		super_obj: Option<ObjValue>,90	) -> Result<LazyVal> {91		match self {92			Self::Bindable(v) => v.bind(s, this, super_obj),93			Self::Bound(v) => Ok(v.clone()),94		}95	}96}9798pub struct EvaluationSettings {99	/// Limits recursion by limiting the number of stack frames100	pub max_stack: usize,101	/// Limits amount of stack trace items preserved102	pub max_trace: usize,103	/// Used for s`td.extVar`104	pub ext_vars: HashMap<IStr, Val>,105	/// Used for ext.native106	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,107	/// TLA vars108	pub tla_vars: HashMap<IStr, TlaArg>,109	/// Global variables are inserted in default context110	pub globals: HashMap<IStr, Val>,111	/// Used to resolve file locations/contents112	pub import_resolver: Box<dyn ImportResolver>,113	/// Used in manifestification functions114	pub manifest_format: ManifestFormat,115	/// Used for bindings116	pub trace_format: Box<dyn TraceFormat>,117}118impl Default for EvaluationSettings {119	fn default() -> Self {120		Self {121			max_stack: 200,122			max_trace: 20,123			globals: HashMap::default(),124			ext_vars: HashMap::default(),125			ext_natives: HashMap::default(),126			tla_vars: HashMap::default(),127			import_resolver: Box::new(DummyImportResolver),128			manifest_format: ManifestFormat::Json {129				padding: 4,130				#[cfg(feature = "exp-preserve-order")]131				preserve_order: false,132			},133			trace_format: Box::new(CompactFormat {134				padding: 4,135				resolver: trace::PathResolver::Absolute,136			}),137		}138	}139}140141#[derive(Default)]142struct EvaluationData {143	/// Used for stack overflow detection, stacktrace is populated on unwind144	stack_depth: usize,145	/// Updated every time stack entry is popt146	stack_generation: usize,147148	breakpoints: Breakpoints,149	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces150	files: GcHashMap<Rc<Path>, FileData>,151	str_files: GcHashMap<Rc<Path>, IStr>,152	bin_files: GcHashMap<Rc<Path>, Rc<[u8]>>,153}154155pub struct FileData {156	source_code: IStr,157	parsed: LocExpr,158	evaluated: Option<Val>,159}160161#[allow(clippy::type_complexity)]162pub struct Breakpoint {163	loc: ExprLocation,164	collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,165}166#[derive(Default)]167struct Breakpoints(Vec<Rc<Breakpoint>>);168impl Breakpoints {169	fn insert(170		&self,171		stack_depth: usize,172		stack_generation: usize,173		loc: &ExprLocation,174		result: Result<Val>,175	) -> Result<Val> {176		if self.0.is_empty() {177			return result;178		}179		for item in &self.0 {180			if item.loc.belongs_to(loc) {181				let mut collected = item.collected.borrow_mut();182				let (depth, vals) = collected.entry(stack_generation).or_default();183				if stack_depth > *depth {184					vals.clear();185				}186				vals.push(result.clone());187			}188		}189		result190	}191}192193#[derive(Default)]194pub struct EvaluationStateInternals {195	/// Internal state196	data: RefCell<EvaluationData>,197	/// Settings, safe to change at runtime198	settings: RefCell<EvaluationSettings>,199}200201/// Maintains stack trace and import resolution202#[derive(Default, Clone)]203pub struct State(Rc<EvaluationStateInternals>);204205impl State {206	/// Parses and adds file as loaded207	pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {208		let parsed = parse(209			&source_code,210			&ParserSettings {211				file_name: path.clone(),212			},213		)214		.map_err(|error| ImportSyntaxError {215			error: Box::new(error),216			path: path.clone(),217			source_code: source_code.clone(),218		})?;219		self.add_parsed_file(path, source_code, parsed.clone())?;220221		Ok(parsed)222	}223224	pub fn reset_evaluation_state(&self, name: &Path) {225		self.data_mut()226			.files227			.get_mut(name)228			.expect("file not found")229			.evaluated230			.take();231	}232233	/// Adds file by source code and parsed expr234	pub fn add_parsed_file(235		&self,236		name: Rc<Path>,237		source_code: IStr,238		parsed: LocExpr,239	) -> Result<()> {240		self.data_mut().files.insert(241			name,242			FileData {243				source_code,244				parsed,245				evaluated: None,246			},247		);248249		Ok(())250	}251	pub fn get_source(&self, name: &Path) -> Option<IStr> {252		let ro_map = &self.data().files;253		ro_map.get(name).map(|value| value.source_code.clone())254	}255	pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {256		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)257	}258	pub fn map_from_source_location(259		&self,260		file: &Path,261		line: usize,262		column: usize,263	) -> Option<usize> {264		location_to_offset(265			&self.get_source(file).expect("file not found"),266			line,267			column,268		)269	}270	pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {271		let file_path = self.resolve_file(from, path)?;272		{273			let data = self.data();274			let files = &data.files;275			if files.contains_key(&file_path as &Path) {276				drop(data);277				return self.evaluate_loaded_file_raw(&file_path);278			}279		}280		let contents = self.load_file_str(&file_path)?;281		self.add_file(file_path.clone(), contents)?;282		self.evaluate_loaded_file_raw(&file_path)283	}284	pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {285		let path = self.resolve_file(from, path)?;286		if !self.data().str_files.contains_key(&path) {287			let file_str = self.load_file_str(&path)?;288			self.data_mut().str_files.insert(path.clone(), file_str);289		}290		Ok(self.data().str_files.get(&path).cloned().unwrap())291	}292	pub(crate) fn import_file_bin(&self, from: &Path, path: &Path) -> Result<Rc<[u8]>> {293		let path = self.resolve_file(from, path)?;294		if !self.data().bin_files.contains_key(&path) {295			let file_bin = self.load_file_bin(&path)?;296			self.data_mut().bin_files.insert(path.clone(), file_bin);297		}298		Ok(self.data().bin_files.get(&path).cloned().unwrap())299	}300301	fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {302		let expr: LocExpr = {303			let ro_map = &self.data().files;304			let value = ro_map305				.get(name)306				.unwrap_or_else(|| panic!("file not added: {:?}", name));307			if let Some(ref evaluated) = value.evaluated {308				return Ok(evaluated.clone());309			}310			value.parsed.clone()311		};312		let value = evaluate(self.clone(), self.create_default_context(), &expr)?;313		{314			self.data_mut()315				.files316				.get_mut(name)317				.unwrap()318				.evaluated319				.replace(value.clone());320		}321		Ok(value)322	}323324	/// Adds standard library global variable (std) to this evaluator325	pub fn with_stdlib(&self) -> &Self {326		use jrsonnet_stdlib::STDLIB_STR;327		let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();328329		self.add_parsed_file(330			std_path.clone(),331			STDLIB_STR.to_owned().into(),332			builtin::get_parsed_stdlib(),333		)334		.expect("stdlib is correct");335		let val = self336			.evaluate_loaded_file_raw(&std_path)337			.expect("stdlib is correct");338		self.settings_mut().globals.insert("std".into(), val);339		self340	}341342	/// Creates context with all passed global variables343	pub fn create_default_context(&self) -> Context {344		let globals = &self.settings().globals;345		let mut new_bindings = GcHashMap::with_capacity(globals.len());346		for (name, value) in globals.iter() {347			new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));348		}349		Context::new().extend_bound(new_bindings)350	}351352	/// Executes code creating a new stack frame353	pub fn push<T>(354		&self,355		e: CallLocation,356		frame_desc: impl FnOnce() -> String,357		f: impl FnOnce() -> Result<T>,358	) -> Result<T> {359		{360			let mut data = self.data_mut();361			let stack_depth = &mut data.stack_depth;362			if *stack_depth > self.max_stack() {363				// Error creation uses data, so i drop guard here364				drop(data);365				throw!(StackOverflow);366			}367			*stack_depth += 1;368		}369		let result = f();370		{371			let mut data = self.data_mut();372			data.stack_depth -= 1;373			data.stack_generation += 1;374		}375		if let Err(mut err) = result {376			err.trace_mut().0.push(StackTraceElement {377				location: e.0.cloned(),378				desc: frame_desc(),379			});380			return Err(err);381		}382		result383	}384385	/// Executes code creating a new stack frame386	pub fn push_val(387		&self,388		e: &ExprLocation,389		frame_desc: impl FnOnce() -> String,390		f: impl FnOnce() -> Result<Val>,391	) -> Result<Val> {392		{393			let mut data = self.data_mut();394			let stack_depth = &mut data.stack_depth;395			if *stack_depth > self.max_stack() {396				// Error creation uses data, so i drop guard here397				drop(data);398				throw!(StackOverflow);399			}400			*stack_depth += 1;401		}402		let mut result = f();403		{404			let mut data = self.data_mut();405			data.stack_depth -= 1;406			data.stack_generation += 1;407			result = data408				.breakpoints409				.insert(data.stack_depth, data.stack_generation, e, result);410		}411		if let Err(mut err) = result {412			err.trace_mut().0.push(StackTraceElement {413				location: Some(e.clone()),414				desc: frame_desc(),415			});416			return Err(err);417		}418		result419	}420	/// Executes code creating a new stack frame421	pub fn push_description<T>(422		&self,423		frame_desc: impl FnOnce() -> String,424		f: impl FnOnce() -> Result<T>,425	) -> Result<T> {426		{427			let mut data = self.data_mut();428			let stack_depth = &mut data.stack_depth;429			if *stack_depth > self.max_stack() {430				// Error creation uses data, so i drop guard here431				drop(data);432				throw!(StackOverflow);433			}434			*stack_depth += 1;435		}436		let result = f();437		{438			let mut data = self.data_mut();439			data.stack_depth -= 1;440			data.stack_generation += 1;441		}442		if let Err(mut err) = result {443			err.trace_mut().0.push(StackTraceElement {444				location: None,445				desc: frame_desc(),446			});447			return Err(err);448		}449		result450	}451452	/// # Panics453	/// In case of formatting failure454	pub fn stringify_err(&self, e: &LocError) -> String {455		let mut out = String::new();456		self.settings()457			.trace_format458			.write_trace(&mut out, self, e)459			.unwrap();460		out461	}462463	pub fn manifest(&self, val: Val) -> Result<IStr> {464		self.push_description(465			|| "manifestification".to_string(),466			|| val.manifest(self.clone(), &self.manifest_format()),467		)468	}469	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {470		val.manifest_multi(self.clone(), &self.manifest_format())471	}472	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {473		val.manifest_stream(self.clone(), &self.manifest_format())474	}475476	/// If passed value is function then call with set TLA477	pub fn with_tla(&self, val: Val) -> Result<Val> {478		Ok(match val {479			Val::Func(func) => self.push_description(480				|| "during TLA call".to_owned(),481				|| {482					func.evaluate(483						self.clone(),484						self.create_default_context(),485						CallLocation::native(),486						&self.settings().tla_vars,487						true,488					)489				},490			)?,491			v => v,492		})493	}494}495496/// Internals497impl State {498	fn data(&self) -> Ref<EvaluationData> {499		self.0.data.borrow()500	}501	fn data_mut(&self) -> RefMut<EvaluationData> {502		self.0.data.borrow_mut()503	}504	pub fn settings(&self) -> Ref<EvaluationSettings> {505		self.0.settings.borrow()506	}507	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {508		self.0.settings.borrow_mut()509	}510}511512/// Raw methods evaluate passed values but don't perform TLA execution513impl State {514	pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {515		self.import_file(&std::env::current_dir().expect("cwd"), name)516	}517	pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {518		self.import_file(&PathBuf::from("."), name)519	}520	/// Parses and evaluates the given snippet521	pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {522		let parsed = parse(523			&code,524			&ParserSettings {525				file_name: source.clone(),526			},527		)528		.map_err(|e| ImportSyntaxError {529			path: source.clone(),530			source_code: code.clone(),531			error: Box::new(e),532		})?;533		self.add_parsed_file(source, code, parsed.clone())?;534		self.evaluate_expr_raw(parsed)535	}536	/// Evaluates the parsed expression537	pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {538		evaluate(self.clone(), self.create_default_context(), &code)539	}540}541542/// Settings utilities543impl State {544	pub fn add_ext_var(&self, name: IStr, value: Val) {545		self.settings_mut().ext_vars.insert(name, value);546	}547	pub fn add_ext_str(&self, name: IStr, value: IStr) {548		self.add_ext_var(name, Val::Str(value));549	}550	pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {551		let value =552			self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;553		self.add_ext_var(name, value);554		Ok(())555	}556557	pub fn add_tla(&self, name: IStr, value: Val) {558		self.settings_mut()559			.tla_vars560			.insert(name, TlaArg::Val(value));561	}562	pub fn add_tla_str(&self, name: IStr, value: IStr) {563		self.settings_mut()564			.tla_vars565			.insert(name, TlaArg::String(value));566	}567	pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {568		let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;569		self.settings_mut()570			.tla_vars571			.insert(name, TlaArg::Code(parsed));572		Ok(())573	}574575	pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {576		self.settings().import_resolver.resolve_file(from, path)577	}578	pub fn load_file_str(&self, path: &Path) -> Result<IStr> {579		self.settings().import_resolver.load_file_str(path)580	}581	pub fn load_file_bin(&self, path: &Path) -> Result<Rc<[u8]>> {582		self.settings().import_resolver.load_file_bin(path)583	}584585	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {586		Ref::map(self.settings(), |s| &*s.import_resolver)587	}588	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {589		self.settings_mut().import_resolver = resolver;590	}591592	pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {593		self.settings_mut().ext_natives.insert(name, cb);594	}595596	pub fn manifest_format(&self) -> ManifestFormat {597		self.settings().manifest_format.clone()598	}599	pub fn set_manifest_format(&self, format: ManifestFormat) {600		self.settings_mut().manifest_format = format;601	}602603	pub fn trace_format(&self) -> Ref<dyn TraceFormat> {604		Ref::map(self.settings(), |s| &*s.trace_format)605	}606	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {607		self.settings_mut().trace_format = format;608	}609610	pub fn max_trace(&self) -> usize {611		self.settings().max_trace612	}613	pub fn set_max_trace(&self, trace: usize) {614		self.settings_mut().max_trace = trace;615	}616617	pub fn max_stack(&self) -> usize {618		self.settings().max_stack619	}620	pub fn set_max_stack(&self, trace: usize) {621		self.settings_mut().max_stack = trace;622	}623}624625pub fn cc_ptr_eq<T>(a: &Cc<T>, b: &Cc<T>) -> bool {626	let a = a as &T;627	let b = b as &T;628	std::ptr::eq(a, b)629}630631fn weak_raw<T>(a: Weak<T>) -> *const () {632	unsafe { std::mem::transmute(a) }633}634fn weak_ptr_eq<T>(a: Weak<T>, b: Weak<T>) -> bool {635	std::ptr::eq(weak_raw(a), weak_raw(b))636}637638#[test]639fn weak_unsafe() {640	let a = Cc::new(1);641	let b = Cc::new(2);642643	let aw1 = a.clone().downgrade();644	let aw2 = a.clone().downgrade();645	let aw3 = a.clone().downgrade();646647	let bw = b.clone().downgrade();648649	assert!(weak_ptr_eq(aw1, aw2));650	assert!(!weak_ptr_eq(aw3, bw));651}652653#[cfg(test)]654pub mod tests {655	use std::{656		path::{Path, PathBuf},657		rc::Rc,658	};659660	use gcmodule::{Cc, Trace};661	use jrsonnet_parser::*;662663	use super::Val;664	use crate::{665		error::Error::*,666		function::{BuiltinParam, CallLocation},667		gc::TraceBox,668		native::NativeCallbackHandler,669		val::primitive_equals,670		State,671	};672673	#[test]674	#[should_panic]675	fn eval_state_stacktrace() {676		let state = State::default();677		state678			.push(679				CallLocation::new(&ExprLocation(PathBuf::from("test1.jsonnet").into(), 10, 20)),680				|| "outer".to_owned(),681				|| {682					state.push(683						CallLocation::new(&ExprLocation(684							PathBuf::from("test2.jsonnet").into(),685							30,686							40,687						)),688						|| "inner".to_owned(),689						|| Err(RuntimeError("".into()).into()),690					)?;691					Ok(Val::Null)692				},693			)694			.unwrap();695	}696697	#[test]698	fn eval_state_standard() {699		let state = State::default();700		state.with_stdlib();701		assert!(primitive_equals(702			&state703				.evaluate_snippet_raw(704					PathBuf::from("raw.jsonnet").into(),705					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#.into()706				)707				.unwrap(),708			&Val::Bool(true),709		)710		.unwrap());711	}712713	macro_rules! eval {714		($str: expr) => {{715			let evaluator = State::default();716			evaluator.with_stdlib();717			evaluator718				.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())719				.unwrap()720		}};721	}722	macro_rules! eval_json {723		($str: expr) => {{724			let evaluator = State::default();725			evaluator.with_stdlib();726			evaluator727				.evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())728				.unwrap()729				.to_json(0)730				.unwrap()731				.replace("\n", "")732		}};733	}734735	/// Asserts given code returns `true`736	macro_rules! assert_eval {737		($str: expr) => {738			assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())739		};740	}741742	/// Asserts given code returns `false`743	macro_rules! assert_eval_neg {744		($str: expr) => {745			assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())746		};747	}748	macro_rules! assert_json {749		($str: expr, $out: expr) => {750			assert_eq!(eval_json!($str), $out.replace("\t", ""))751		};752	}753754	/// Sanity checking, before trusting to another tests755	#[test]756	fn equality_operator() {757		assert_eval!("2 == 2");758		assert_eval_neg!("2 != 2");759		assert_eval!("2 != 3");760		assert_eval_neg!("2 == 3");761		assert_eval!("'Hello' == 'Hello'");762		assert_eval_neg!("'Hello' != 'Hello'");763		assert_eval!("'Hello' != 'World'");764		assert_eval_neg!("'Hello' == 'World'");765	}766767	#[test]768	fn math_evaluation() {769		assert_eval!("2 + 2 * 2 == 6");770		assert_eval!("3 + (2 + 2 * 2) == 9");771	}772773	#[test]774	fn string_concat() {775		assert_eval!("'Hello' + 'World' == 'HelloWorld'");776		assert_eval!("'Hello' * 3 == 'HelloHelloHello'");777		assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");778	}779780	#[test]781	fn faster_join() {782		assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");783		assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");784	}785786	#[test]787	fn function_contexts() {788		assert_eval!(789			r#"790				local k = {791					t(name = self.h): [self.h, name],792					h: 3,793				};794				local f = {795					t: k.t(),796					h: 4,797				};798				f.t[0] == f.t[1]799			"#800		);801	}802803	#[test]804	fn local() {805		assert_eval!("local a = 2; local b = 3; a + b == 5");806		assert_eval!("local a = 1, b = a + 1; a + b == 3");807		assert_eval!("local a = 1; local a = 2; a == 2");808	}809810	#[test]811	fn object_lazyness() {812		assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);813	}814815	#[test]816	fn object_inheritance() {817		assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);818	}819820	#[test]821	fn object_assertion_success() {822		eval!("{assert \"a\" in self} + {a:2}");823	}824825	#[test]826	fn object_assertion_error() {827		eval!("{assert \"a\" in self}");828	}829830	#[test]831	fn lazy_args() {832		eval!("local test(a) = 2; test(error '3')");833	}834835	#[test]836	#[should_panic]837	fn tailstrict_args() {838		eval!("local test(a) = 2; test(error '3') tailstrict");839	}840841	#[test]842	#[should_panic]843	fn no_binding_error() {844		eval!("a");845	}846847	#[test]848	fn test_object() {849		assert_json!("{a:2}", r#"{"a": 2}"#);850		assert_json!("{a:2+2}", r#"{"a": 4}"#);851		assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);852		assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);853		assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);854		assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);855		assert_json!(856			r#"857				{858					name: "Alice",859					welcome: "Hello " + self.name + "!",860				}861			"#,862			r#"{"name": "Alice","welcome": "Hello Alice!"}"#863		);864		assert_json!(865			r#"866				{867					name: "Alice",868					welcome: "Hello " + self.name + "!",869				} + {870					name: "Bob"871				}872			"#,873			r#"{"name": "Bob","welcome": "Hello Bob!"}"#874		);875	}876877	#[test]878	fn functions() {879		assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");880		assert_json!(881			r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,882			r#""HelloDearWorld""#883		);884	}885886	#[test]887	fn local_methods() {888		assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");889		assert_json!(890			r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,891			r#""HelloDearWorld""#892		);893	}894895	#[test]896	fn object_locals() {897		assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);898		assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);899		assert_json!(900			r#"{local a = function (b) {[b]:4}, test: a("test")}"#,901			r#"{"test": {"test": 4}}"#902		);903	}904905	#[test]906	fn object_comp() {907		assert_json!(908			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}"#,909			"{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"910		)911	}912913	#[test]914	fn direct_self() {915		println!(916			"{:#?}",917			eval!(918				r#"919					{920						local me = self,921						a: 3,922						b(): me.a,923					}924				"#925			)926		);927	}928929	#[test]930	fn indirect_self() {931		// `self` assigned to `me` was lost when being932		// referenced from field933		eval!(934			r#"{935				local me = self,936				a: 3,937				b: me.a,938			}.b"#939		);940	}941942	// We can't trust other tests (And official jsonnet testsuite), if assert is not working correctly943	#[test]944	fn std_assert_ok() {945		eval!("std.assertEqual(4.5 << 2, 16)");946	}947948	#[test]949	#[should_panic]950	fn std_assert_failure() {951		eval!("std.assertEqual(4.5 << 2, 15)");952	}953954	#[test]955	fn string_is_string() {956		assert!(primitive_equals(957			&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),958			&Val::Bool(false),959		)960		.unwrap());961	}962963	#[test]964	fn base64_works() {965		assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);966	}967968	#[test]969	fn utf8_chars() {970		assert_json!(971			r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,972			r#"{"c": 128526,"l": 1}"#973		)974	}975976	#[test]977	fn json() {978		assert_json!(979			r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,980			r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#981		);982	}983984	#[test]985	fn json_minified() {986		assert_json!(987			r#"std.manifestJsonMinified({a:3, b:4, c:6})"#,988			r#""{\"a\":3,\"b\":4,\"c\":6}""#989		);990	}991992	#[test]993	fn parse_json() {994		assert_json!(995			r#"std.parseJson('{"a": -1,"b": 1,"c": 3.141,"d": []}')"#,996			r#"{"a": -1,"b": 1,"c": 3.141,"d": []}"#997		);998	}9991000	#[test]1001	fn test() {1002		assert_json!(1003			r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,1004			"[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"1005		);1006	}10071008	#[test]1009	fn sjsonnet() {1010		eval!(1011			r#"1012			local x0 = {k: 1};1013			local x1 = {k: x0.k + x0.k};1014			local x2 = {k: x1.k + x1.k};1015			local x3 = {k: x2.k + x2.k};1016			local x4 = {k: x3.k + x3.k};1017			local x5 = {k: x4.k + x4.k};1018			local x6 = {k: x5.k + x5.k};1019			local x7 = {k: x6.k + x6.k};1020			local x8 = {k: x7.k + x7.k};1021			local x9 = {k: x8.k + x8.k};1022			local x10 = {k: x9.k + x9.k};1023			local x11 = {k: x10.k + x10.k};1024			local x12 = {k: x11.k + x11.k};1025			local x13 = {k: x12.k + x12.k};1026			local x14 = {k: x13.k + x13.k};1027			local x15 = {k: x14.k + x14.k};1028			local x16 = {k: x15.k + x15.k};1029			local x17 = {k: x16.k + x16.k};1030			local x18 = {k: x17.k + x17.k};1031			local x19 = {k: x18.k + x18.k};1032			local x20 = {k: x19.k + x19.k};1033			local x21 = {k: x20.k + x20.k};1034			x21.k1035		"#1036		);1037	}10381039	// This test is commented out by default, because of huge compilation slowdown1040	// #[bench]1041	// fn bench_codegen(b: &mut Bencher) {1042	// 	b.iter(|| {1043	// 		#[allow(clippy::all)]1044	// 		let stdlib = {1045	// 			use jrsonnet_parser::*;1046	// 			include!(concat!(env!("OUT_DIR"), "/stdlib.rs"))1047	// 		};1048	// 		stdlib1049	// 	})1050	// }10511052	/*1053	#[bench]1054	fn bench_serialize(b: &mut Bencher) {1055		b.iter(|| {1056			bincode::deserialize::<jrsonnet_parser::LocExpr>(include_bytes!(concat!(1057				env!("OUT_DIR"),1058				"/stdlib.bincode"1059			)))1060			.expect("deserialize stdlib")1061		})1062	}10631064	#[bench]1065	fn bench_parse(b: &mut Bencher) {1066		b.iter(|| {1067			jrsonnet_parser::parse(1068				jrsonnet_stdlib::STDLIB_STR,1069				&jrsonnet_parser::ParserSettings {1070					loc_data: true,1071					file_name: Rc::new(PathBuf::from("std.jsonnet")),1072				},1073			)1074		})1075	}1076	*/10771078	#[test]1079	fn equality() {1080		println!(1081			"{:?}",1082			jrsonnet_parser::parse(1083				"{ x: 1, y: 2 } == { x: 1, y: 2 }",1084				&ParserSettings {1085					file_name: PathBuf::from("equality").into(),1086				}1087			)1088		);1089		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")1090	}10911092	#[test]1093	fn native_ext() -> crate::error::Result<()> {1094		use super::native::NativeCallback;1095		let evaluator = State::default();10961097		evaluator.with_stdlib();10981099		#[derive(Trace)]1100		struct NativeAdd;1101		impl NativeCallbackHandler for NativeAdd {1102			fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {1103				assert_eq!(1104					&from.unwrap() as &Path,1105					&PathBuf::from("native_caller.jsonnet")1106				);1107				match (&args[0], &args[1]) {1108					(Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),1109					(_, _) => unreachable!(),1110				}1111			}1112		}1113		evaluator.settings_mut().ext_natives.insert(1114			"native_add".into(),1115			#[allow(deprecated)]1116			Cc::new(TraceBox(Box::new(NativeCallback::new(1117				vec![1118					BuiltinParam {1119						name: "a".into(),1120						has_default: false,1121					},1122					BuiltinParam {1123						name: "b".into(),1124						has_default: false,1125					},1126				],1127				TraceBox(Box::new(NativeAdd)),1128			)))),1129		);1130		dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1131		evaluator.evaluate_snippet_raw(1132			PathBuf::from("native_caller.jsonnet").into(),1133			"std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),1134		)?;1135		dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1136		Ok(())1137	}11381139	#[test]1140	fn constant_intrinsic() -> crate::error::Result<()> {1141		assert_eval!(1142			"local std2 = std; local std = std2 { primitiveEquals(a, b):: false }; 1 == 1"1143		);1144		Ok(())1145	}11461147	#[test]1148	fn standalone_super() -> crate::error::Result<()> {1149		assert_eval!(1150			r#"1151			local obj = {1152				a: 1,1153				b: 2,1154				c: 3,1155			};1156			local test = obj + {1157				fields: std.objectFields(super),1158				d: 5,1159			};1160			test.fields == ['a', 'b', 'c']1161		"#1162		);1163		Ok(())1164	}11651166	#[test]1167	fn comp_self() -> crate::error::Result<()> {1168		assert_eval!(1169			r#"1170			std.objectFields({1171				a:{1172					[name]: name for name in std.objectFields(self)1173				},1174				b: 2,1175				c: 3,1176			}.a) == ['a', 'b', 'c']1177			"#1178		);11791180		Ok(())1181	}11821183	struct TestImportResolver(Vec<u8>);1184	impl crate::import::ImportResolver for TestImportResolver {1185		fn resolve_file(&self, _: &Path, _: &Path) -> crate::error::Result<Rc<Path>> {1186			Ok(PathBuf::from("/test").into())1187		}11881189		fn load_file_contents(&self, _: &Path) -> crate::error::Result<Vec<u8>> {1190			Ok(self.0.clone())1191		}11921193		unsafe fn as_any(&self) -> &dyn std::any::Any {1194			panic!()1195		}11961197		fn load_file_bin(&self, _resolved: &Path) -> crate::error::Result<Rc<[u8]>> {1198			panic!()1199		}1200	}12011202	#[test]1203	fn issue_23() {1204		let state = State::default();1205		state.set_import_resolver(Box::new(TestImportResolver(r#"import "/test""#.into())));1206		let _ = state.evaluate_file_raw(&PathBuf::from("/test"));1207	}12081209	#[test]1210	fn issue_40() {1211		let state = State::default();1212		state.with_stdlib();12131214		let error = state1215			.evaluate_snippet_raw(1216				PathBuf::from("issue40.jsonnet").into(),1217				r#"1218				local conf = {1219					n: ""1220				};12211222				local result = conf + {1223					assert std.isNumber(self.n): "is number"1224				};12251226				std.manifestJsonEx(result, "")1227			"#1228				.into(),1229			)1230			.unwrap_err();1231		assert_eq!(error.error().to_string(), "assert failed: is number");1232	}12331234	#[test]1235	fn test_ascii_upper_lower() {1236		assert_eval!(r#"std.assertEqual(std.asciiUpper("aBc😀"), "ABC😀")"#);1237		assert_eval!(r#"std.assertEqual(std.asciiLower("aBc😀"), "abc😀")"#);1238	}12391240	#[test]1241	fn test_member() {1242		assert_eval!(r#"!std.member("", "")"#);1243		assert_eval!(r#"std.member("abc", "a")"#);1244		assert_eval!(r#"!std.member("abc", "d")"#);1245		assert_eval!(r#"!std.member([], "")"#);1246		assert_eval!(r#"std.member(["a", "b", "c"], "a")"#);1247		assert_eval!(r#"!std.member(["a", "b", "c"], "d")"#);1248	}12491250	#[test]1251	fn test_count() {1252		assert_eval!(r#"std.assertEqual(std.count([], ""), 0)"#);1253		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "d"), 0)"#);1254		assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "a"), 2)"#);1255	}1256}