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

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	// False positives21	// https://github.com/rust-lang/rust-clippy/issues/690222	clippy::use_self,23	// https://github.com/rust-lang/rust-clippy/issues/853924	clippy::iter_with_drain,25)]2627// For jrsonnet-macros28extern crate self as jrsonnet_evaluator;2930mod ctx;31mod dynamic;32pub mod error;33mod evaluate;34pub mod function;35pub mod gc;36mod import;37mod integrations;38mod map;39mod obj;40mod stdlib;41pub mod trace;42pub mod typed;43pub mod val;4445use std::{46	borrow::Cow,47	cell::{Ref, RefCell, RefMut},48	collections::HashMap,49	fmt::{self, Debug},50	path::{Path, PathBuf},51	rc::Rc,52};5354pub use ctx::*;55pub use dynamic::*;56use error::{Error::*, LocError, Result, StackTraceElement};57pub use evaluate::*;58use function::{builtin::Builtin, CallLocation, TlaArg};59use gc::{GcHashMap, TraceBox};60use hashbrown::hash_map::RawEntryMut;61pub use import::*;62use jrsonnet_gcmodule::{Cc, Trace};63use jrsonnet_interner::IBytes;64pub use jrsonnet_interner::IStr;65pub use jrsonnet_parser as parser;66use jrsonnet_parser::*;67pub use obj::*;68use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};69pub use val::{ManifestFormat, Thunk, Val};7071pub trait Unbound: Trace {72	type Bound;73	fn bind(&self, s: State, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;74}7576#[derive(Clone, Trace)]77pub enum LazyBinding {78	Bindable(Cc<TraceBox<dyn Unbound<Bound = Thunk<Val>>>>),79	Bound(Thunk<Val>),80}8182impl Debug for LazyBinding {83	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {84		write!(f, "LazyBinding")85	}86}87impl LazyBinding {88	pub fn evaluate(89		&self,90		s: State,91		sup: Option<ObjValue>,92		this: Option<ObjValue>,93	) -> Result<Thunk<Val>> {94		match self {95			Self::Bindable(v) => v.bind(s, sup, this),96			Self::Bound(v) => Ok(v.clone()),97		}98	}99}100101pub struct EvaluationSettings {102	/// Limits recursion by limiting the number of stack frames103	pub max_stack: usize,104	/// Limits amount of stack trace items preserved105	pub max_trace: usize,106	/// Used for s`td.extVar`107	pub ext_vars: HashMap<IStr, TlaArg>,108	/// Used for ext.native109	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,110	/// TLA vars111	pub tla_vars: HashMap<IStr, TlaArg>,112	/// Global variables are inserted in default context113	pub globals: HashMap<IStr, Val>,114	/// Used to resolve file locations/contents115	pub import_resolver: Box<dyn ImportResolver>,116	/// Used in manifestification functions117	pub manifest_format: ManifestFormat,118	/// Used for bindings119	pub trace_format: Box<dyn TraceFormat>,120}121impl Default for EvaluationSettings {122	fn default() -> Self {123		Self {124			max_stack: 200,125			max_trace: 20,126			globals: HashMap::default(),127			ext_vars: HashMap::default(),128			ext_natives: HashMap::default(),129			tla_vars: HashMap::default(),130			import_resolver: Box::new(DummyImportResolver),131			manifest_format: ManifestFormat::Json {132				padding: 4,133				#[cfg(feature = "exp-preserve-order")]134				preserve_order: false,135			},136			trace_format: Box::new(CompactFormat {137				padding: 4,138				resolver: trace::PathResolver::Absolute,139			}),140		}141	}142}143144#[derive(Default)]145struct EvaluationData {146	/// Used for stack overflow detection, stacktrace is populated on unwind147	stack_depth: usize,148	/// Updated every time stack entry is popt149	stack_generation: usize,150151	breakpoints: Breakpoints,152153	/// Contains file source codes and evaluation results for imports and pretty-printed stacktraces154	files: GcHashMap<PathBuf, FileData>,155	/// Contains tla arguments and others, which aren't needed to be obtained by name156	volatile_files: GcHashMap<String, String>,157}158struct FileData {159	string: Option<IStr>,160	bytes: Option<IBytes>,161	parsed: Option<LocExpr>,162	evaluated: Option<Val>,163164	evaluating: bool,165}166impl FileData {167	fn new_string(data: IStr) -> Self {168		Self {169			string: Some(data),170			bytes: None,171			parsed: None,172			evaluated: None,173			evaluating: false,174		}175	}176	fn new_bytes(data: IBytes) -> Self {177		Self {178			string: None,179			bytes: Some(data),180			parsed: None,181			evaluated: None,182			evaluating: false,183		}184	}185}186187#[allow(clippy::type_complexity)]188pub struct Breakpoint {189	loc: ExprLocation,190	collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,191}192#[derive(Default)]193struct Breakpoints(Vec<Rc<Breakpoint>>);194impl Breakpoints {195	fn insert(196		&self,197		stack_depth: usize,198		stack_generation: usize,199		loc: &ExprLocation,200		result: Result<Val>,201	) -> Result<Val> {202		if self.0.is_empty() {203			return result;204		}205		for item in &self.0 {206			if item.loc.belongs_to(loc) {207				let mut collected = item.collected.borrow_mut();208				let (depth, vals) = collected.entry(stack_generation).or_default();209				if stack_depth > *depth {210					vals.clear();211				}212				vals.push(result.clone());213			}214		}215		result216	}217}218219#[derive(Default)]220pub struct EvaluationStateInternals {221	/// Internal state222	data: RefCell<EvaluationData>,223	/// Settings, safe to change at runtime224	settings: RefCell<EvaluationSettings>,225}226227/// Maintains stack trace and import resolution228#[derive(Default, Clone)]229pub struct State(Rc<EvaluationStateInternals>);230231impl State {232	pub fn import_str(&self, path: PathBuf) -> Result<IStr> {233		let mut data = self.data_mut();234		let mut file = data.files.raw_entry_mut().from_key(&path);235236		let file = match file {237			RawEntryMut::Occupied(ref mut d) => d.get_mut(),238			RawEntryMut::Vacant(v) => {239				let data = self.settings().import_resolver.load_file_contents(&path)?;240				v.insert(241					path.clone(),242					FileData::new_string(243						std::str::from_utf8(&data)244							.map_err(|_| ImportBadFileUtf8(path.clone()))?245							.into(),246					),247				)248				.1249			}250		};251		if let Some(str) = &file.string {252			return Ok(str.clone());253		}254		if file.string.is_none() {255			file.string = Some(256				file.bytes257					.as_ref()258					.expect("either string or bytes should be set")259					.clone()260					.cast_str()261					.ok_or_else(|| ImportBadFileUtf8(path.clone()))?,262			);263		}264		Ok(file.string.as_ref().expect("just set").clone())265	}266	pub fn import_bin(&self, path: PathBuf) -> Result<IBytes> {267		let mut data = self.data_mut();268		let mut file = data.files.raw_entry_mut().from_key(&path);269270		let file = match file {271			RawEntryMut::Occupied(ref mut d) => d.get_mut(),272			RawEntryMut::Vacant(v) => {273				let data = self.settings().import_resolver.load_file_contents(&path)?;274				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))275					.1276			}277		};278		if let Some(str) = &file.bytes {279			return Ok(str.clone());280		}281		if file.bytes.is_none() {282			file.bytes = Some(283				file.string284					.as_ref()285					.expect("either string or bytes should be set")286					.clone()287					.cast_bytes(),288			);289		}290		Ok(file.bytes.as_ref().expect("just set").clone())291	}292	pub fn import(&self, path: PathBuf) -> Result<Val> {293		let mut data = self.data_mut();294		let mut file = data.files.raw_entry_mut().from_key(&path);295296		let file = match file {297			RawEntryMut::Occupied(ref mut d) => d.get_mut(),298			RawEntryMut::Vacant(v) => {299				let data = self.settings().import_resolver.load_file_contents(&path)?;300				v.insert(301					path.clone(),302					FileData::new_string(303						std::str::from_utf8(&data)304							.map_err(|_| ImportBadFileUtf8(path.clone()))?305							.into(),306					),307				)308				.1309			}310		};311		if let Some(val) = &file.evaluated {312			return Ok(val.clone());313		}314		if file.string.is_none() {315			file.string = Some(316				std::str::from_utf8(317					file.bytes318						.as_ref()319						.expect("either string or bytes should be set"),320				)321				.map_err(|_| ImportBadFileUtf8(path.clone()))?322				.into(),323			);324		}325		let code = file.string.as_ref().expect("just set");326		let file_name = Source::new(path.clone()).expect("resolver should return correct name");327		if file.parsed.is_none() {328			file.parsed = Some(329				jrsonnet_parser::parse(330					code,331					&ParserSettings {332						file_name: file_name.clone(),333					},334				)335				.map_err(|e| ImportSyntaxError {336					path: file_name,337					source_code: code.clone(),338					error: Box::new(e),339				})?,340			);341		}342		let parsed = file.parsed.as_ref().expect("just set").clone();343		if file.evaluating {344			throw!(InfiniteRecursionDetected)345		}346		file.evaluating = true;347		// Dropping file here, as it borrows data, which may be used in evaluation348		drop(data);349		let res = evaluate(self.clone(), self.create_default_context(), &parsed);350351		let mut data = self.data_mut();352		let mut file = data.files.raw_entry_mut().from_key(&path);353354		let file = match file {355			RawEntryMut::Occupied(ref mut d) => d.get_mut(),356			RawEntryMut::Vacant(_) => unreachable!("this file was just here!"),357		};358		file.evaluating = false;359		match res {360			Ok(v) => {361				file.evaluated = Some(v.clone());362				Ok(v)363			}364			Err(e) => Err(e),365		}366	}367368	pub fn get_source(&self, name: Source) -> Option<String> {369		let data = self.data();370		match name.repr() {371			Ok(real) => data372				.files373				.get(real)374				.and_then(|f| f.string.as_ref())375				.map(ToString::to_string),376			Err(e) => data.volatile_files.get(e).map(ToOwned::to_owned),377		}378	}379	pub fn map_source_locations(&self, file: Source, locs: &[u32]) -> Vec<CodeLocation> {380		offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)381	}382	pub fn map_from_source_location(383		&self,384		file: Source,385		line: usize,386		column: usize,387	) -> Option<usize> {388		location_to_offset(389			&self.get_source(file).expect("file not found"),390			line,391			column,392		)393	}394	/// Adds standard library global variable (std) to this evaluator395	pub fn with_stdlib(&self) -> &Self {396		let val = evaluate(397			self.clone(),398			self.create_default_context(),399			&stdlib::get_parsed_stdlib(),400		)401		.expect("std should not fail");402		self.settings_mut().globals.insert("std".into(), val);403		self404	}405406	/// Creates context with all passed global variables407	pub fn create_default_context(&self) -> Context {408		let globals = &self.settings().globals;409		let mut new_bindings = GcHashMap::with_capacity(globals.len());410		for (name, value) in globals.iter() {411			new_bindings.insert(name.clone(), Thunk::evaluated(value.clone()));412		}413		Context::new().extend(new_bindings, None, None, None)414	}415416	/// Executes code creating a new stack frame417	pub fn push<T>(418		&self,419		e: CallLocation,420		frame_desc: impl FnOnce() -> String,421		f: impl FnOnce() -> Result<T>,422	) -> Result<T> {423		{424			let mut data = self.data_mut();425			let stack_depth = &mut data.stack_depth;426			if *stack_depth > self.max_stack() {427				// Error creation uses data, so i drop guard here428				drop(data);429				throw!(StackOverflow);430			}431			*stack_depth += 1;432		}433		let result = f();434		{435			let mut data = self.data_mut();436			data.stack_depth -= 1;437			data.stack_generation += 1;438		}439		if let Err(mut err) = result {440			err.trace_mut().0.push(StackTraceElement {441				location: e.0.cloned(),442				desc: frame_desc(),443			});444			return Err(err);445		}446		result447	}448449	/// Executes code creating a new stack frame450	pub fn push_val(451		&self,452		e: &ExprLocation,453		frame_desc: impl FnOnce() -> String,454		f: impl FnOnce() -> Result<Val>,455	) -> Result<Val> {456		{457			let mut data = self.data_mut();458			let stack_depth = &mut data.stack_depth;459			if *stack_depth > self.max_stack() {460				// Error creation uses data, so i drop guard here461				drop(data);462				throw!(StackOverflow);463			}464			*stack_depth += 1;465		}466		let mut result = f();467		{468			let mut data = self.data_mut();469			data.stack_depth -= 1;470			data.stack_generation += 1;471			result = data472				.breakpoints473				.insert(data.stack_depth, data.stack_generation, e, result);474		}475		if let Err(mut err) = result {476			err.trace_mut().0.push(StackTraceElement {477				location: Some(e.clone()),478				desc: frame_desc(),479			});480			return Err(err);481		}482		result483	}484	/// Executes code creating a new stack frame485	pub fn push_description<T>(486		&self,487		frame_desc: impl FnOnce() -> String,488		f: impl FnOnce() -> Result<T>,489	) -> Result<T> {490		{491			let mut data = self.data_mut();492			let stack_depth = &mut data.stack_depth;493			if *stack_depth > self.max_stack() {494				// Error creation uses data, so i drop guard here495				drop(data);496				throw!(StackOverflow);497			}498			*stack_depth += 1;499		}500		let result = f();501		{502			let mut data = self.data_mut();503			data.stack_depth -= 1;504			data.stack_generation += 1;505		}506		if let Err(mut err) = result {507			err.trace_mut().0.push(StackTraceElement {508				location: None,509				desc: frame_desc(),510			});511			return Err(err);512		}513		result514	}515516	/// # Panics517	/// In case of formatting failure518	pub fn stringify_err(&self, e: &LocError) -> String {519		let mut out = String::new();520		self.settings()521			.trace_format522			.write_trace(&mut out, self, e)523			.unwrap();524		out525	}526527	pub fn manifest(&self, val: Val) -> Result<IStr> {528		self.push_description(529			|| "manifestification".to_string(),530			|| val.manifest(self.clone(), &self.manifest_format()),531		)532	}533	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {534		val.manifest_multi(self.clone(), &self.manifest_format())535	}536	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {537		val.manifest_stream(self.clone(), &self.manifest_format())538	}539540	/// If passed value is function then call with set TLA541	pub fn with_tla(&self, val: Val) -> Result<Val> {542		Ok(match val {543			Val::Func(func) => self.push_description(544				|| "during TLA call".to_owned(),545				|| {546					func.evaluate(547						self.clone(),548						self.create_default_context(),549						CallLocation::native(),550						&self.settings().tla_vars,551						true,552					)553				},554			)?,555			v => v,556		})557	}558}559560/// Internals561impl State {562	fn data(&self) -> Ref<EvaluationData> {563		self.0.data.borrow()564	}565	fn data_mut(&self) -> RefMut<EvaluationData> {566		self.0.data.borrow_mut()567	}568	pub fn settings(&self) -> Ref<EvaluationSettings> {569		self.0.settings.borrow()570	}571	pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {572		self.0.settings.borrow_mut()573	}574}575576/// Raw methods evaluate passed values but don't perform TLA execution577impl State {578	/// Parses and evaluates the given snippet579	pub fn evaluate_snippet(&self, name: String, code: String) -> Result<Val> {580		let source = Source::new_virtual(Cow::Owned(name.clone()));581		let parsed = jrsonnet_parser::parse(582			&code,583			&ParserSettings {584				file_name: source.clone(),585			},586		)587		.map_err(|e| ImportSyntaxError {588			path: source,589			source_code: code.clone().into(),590			error: Box::new(e),591		})?;592		self.data_mut().volatile_files.insert(name, code);593		evaluate(self.clone(), self.create_default_context(), &parsed)594	}595}596597/// Settings utilities598impl State {599	pub fn add_ext_var(&self, name: IStr, value: Val) {600		self.settings_mut()601			.ext_vars602			.insert(name, TlaArg::Val(value));603	}604	pub fn add_ext_str(&self, name: IStr, value: IStr) {605		self.settings_mut()606			.ext_vars607			.insert(name, TlaArg::String(value));608	}609	pub fn add_ext_code(&self, name: &str, code: String) -> Result<()> {610		let source_name = format!("<extvar:{}>", name);611		let source = Source::new_virtual(Cow::Owned(source_name.clone()));612		let parsed = jrsonnet_parser::parse(613			&code,614			&ParserSettings {615				file_name: source.clone(),616			},617		)618		.map_err(|e| ImportSyntaxError {619			path: source,620			source_code: code.clone().into(),621			error: Box::new(e),622		})?;623		self.data_mut().volatile_files.insert(source_name, code);624		self.settings_mut()625			.ext_vars626			.insert(name.into(), TlaArg::Code(parsed));627		Ok(())628	}629630	pub fn add_tla(&self, name: IStr, value: Val) {631		self.settings_mut()632			.tla_vars633			.insert(name, TlaArg::Val(value));634	}635	pub fn add_tla_str(&self, name: IStr, value: IStr) {636		self.settings_mut()637			.tla_vars638			.insert(name, TlaArg::String(value));639	}640	pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {641		let source_name = format!("<top-level-arg:{}>", name);642		let source = Source::new_virtual(Cow::Owned(source_name.clone()));643		let parsed = jrsonnet_parser::parse(644			code,645			&ParserSettings {646				file_name: source.clone(),647			},648		)649		.map_err(|e| ImportSyntaxError {650			path: source,651			source_code: code.into(),652			error: Box::new(e),653		})?;654		self.data_mut()655			.volatile_files656			.insert(source_name, code.to_owned());657		self.settings_mut()658			.tla_vars659			.insert(name, TlaArg::Code(parsed));660		Ok(())661	}662663	pub fn resolve_file(&self, from: &Path, path: &str) -> Result<PathBuf> {664		self.settings()665			.import_resolver666			.resolve_file(from, path.as_ref())667	}668669	pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {670		Ref::map(self.settings(), |s| &*s.import_resolver)671	}672	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {673		self.settings_mut().import_resolver = resolver;674	}675676	pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {677		self.settings_mut().ext_natives.insert(name, cb);678	}679680	pub fn manifest_format(&self) -> ManifestFormat {681		self.settings().manifest_format.clone()682	}683	pub fn set_manifest_format(&self, format: ManifestFormat) {684		self.settings_mut().manifest_format = format;685	}686687	pub fn trace_format(&self) -> Ref<dyn TraceFormat> {688		Ref::map(self.settings(), |s| &*s.trace_format)689	}690	pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {691		self.settings_mut().trace_format = format;692	}693694	pub fn max_trace(&self) -> usize {695		self.settings().max_trace696	}697	pub fn set_max_trace(&self, trace: usize) {698		self.settings_mut().max_trace = trace;699	}700701	pub fn max_stack(&self) -> usize {702		self.settings().max_stack703	}704	pub fn set_max_stack(&self, trace: usize) {705		self.settings_mut().max_stack = trace;706	}707}