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

1//! jsonnet interpreter implementation2#![cfg_attr(feature = "nightly", feature(thread_local, type_alias_impl_trait))]3#![deny(unsafe_op_in_unsafe_fn)]4#![warn(5	clippy::all,6	clippy::nursery,7	clippy::pedantic,8	// missing_docs,9	elided_lifetimes_in_paths,10	explicit_outlives_requirements,11	noop_method_call,12	single_use_lifetimes,13	variant_size_differences,14	rustdoc::all15)]16#![allow(17	macro_expanded_macro_exports_accessed_by_absolute_paths,18	clippy::ptr_arg,19	// Too verbose20	clippy::must_use_candidate,21	// A lot of functions pass around errors thrown by code22	clippy::missing_errors_doc,23	// A lot of pointers have interior Rc24	clippy::needless_pass_by_value,25	// Its fine26	clippy::wildcard_imports,27	clippy::enum_glob_use,28	clippy::module_name_repetitions,29	// TODO: fix individual issues, however this works as intended almost everywhere30	clippy::cast_precision_loss,31	clippy::cast_possible_wrap,32	clippy::cast_possible_truncation,33	clippy::cast_sign_loss,34	// False positives35	// https://github.com/rust-lang/rust-clippy/issues/690236	clippy::use_self,37	// https://github.com/rust-lang/rust-clippy/issues/853938	clippy::iter_with_drain,39	clippy::type_repetition_in_bounds,40	// ci is being run with nightly, but library should work on stable41	clippy::missing_const_for_fn,42	// too many false-positives with .expect() calls43	clippy::missing_panics_doc,44)]4546// For jrsonnet-macros47extern crate self as jrsonnet_evaluator;4849mod arr;50#[cfg(feature = "async-import")]51pub mod async_import;52mod ctx;53mod dynamic;54pub mod error;55mod evaluate;56pub mod function;57pub mod gc;58mod import;59mod integrations;60pub mod manifest;61mod map;62mod obj;63pub mod stack;64pub mod stdlib;65mod tla;66pub mod trace;67pub mod typed;68pub mod val;6970use std::{71	any::Any,72	cell::{Ref, RefCell, RefMut},73	fmt::{self, Debug},74	path::Path,75};7677pub use ctx::*;78pub use dynamic::*;79pub use error::{Error, ErrorKind::*, Result, ResultExt};80pub use evaluate::*;81use function::CallLocation;82use gc::{GcHashMap, TraceBox};83use hashbrown::hash_map::RawEntryMut;84pub use import::*;85use jrsonnet_gcmodule::{Cc, Trace};86pub use jrsonnet_interner::{IBytes, IStr};87pub use jrsonnet_parser as parser;88use jrsonnet_parser::*;89pub use obj::*;90use stack::check_depth;91pub use tla::apply_tla;92pub use val::{Thunk, Val};9394/// Thunk without bound `super`/`this`95/// object inheritance may be overriden multiple times, and will be fixed only on field read96pub trait Unbound: Trace {97	/// Type of value after object context is bound98	type Bound;99	/// Create value bound to specified object context100	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;101}102103/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code104/// Standard jsonnet fields are always unbound105#[derive(Clone, Trace)]106pub enum MaybeUnbound {107	/// Value needs to be bound to `this`/`super`108	Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),109	/// Value is object-independent110	Bound(Thunk<Val>),111}112113impl Debug for MaybeUnbound {114	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {115		write!(f, "MaybeUnbound")116	}117}118impl MaybeUnbound {119	/// Attach object context to value, if required120	pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {121		match self {122			Self::Unbound(v) => v.bind(sup, this),123			Self::Bound(v) => Ok(v.evaluate()?),124		}125	}126}127128/// During import, this trait will be called to create initial context for file.129/// It may initialize global variables, stdlib for example.130pub trait ContextInitializer: Trace {131	/// For which size the builder should be preallocated132	fn reserve_vars(&self) -> usize {133		0134	}135	/// Initialize default file context.136	/// Has default implementation, which calls `populate`.137	/// Prefer to always implement `populate` instead.138	fn initialize(&self, state: State, for_file: Source) -> Context {139		let mut builder = ContextBuilder::with_capacity(state, self.reserve_vars());140		self.populate(for_file, &mut builder);141		builder.build()142	}143	/// For composability: extend builder. May panic if this initialization is not supported,144	/// and the context may only be created via `initialize`.145	fn populate(&self, for_file: Source, builder: &mut ContextBuilder);146	/// Allows upcasting from abstract to concrete context initializer.147	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.148	fn as_any(&self) -> &dyn Any;149}150151/// Context initializer which adds nothing.152impl ContextInitializer for () {153	fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}154	fn as_any(&self) -> &dyn Any {155		self156	}157}158159macro_rules! impl_context_initializer {160	($($gen:ident)*) => {161		#[allow(non_snake_case)]162		impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {163			fn reserve_vars(&self) -> usize {164				let mut out = 0;165				let ($($gen,)*) = self;166				$(out += $gen.reserve_vars();)*167				out168			}169			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {170				let ($($gen,)*) = self;171				$($gen.populate(for_file.clone(), builder);)*172			}173			fn as_any(&self) -> &dyn Any {174				self175			}176		}177	};178	($($cur:ident)* @ $c:ident $($rest:ident)*) => {179		impl_context_initializer!($($cur)*);180		impl_context_initializer!($($cur)* $c @ $($rest)*);181	};182	($($cur:ident)* @) => {183		impl_context_initializer!($($cur)*);184	}185}186impl_context_initializer! {187	A @ B C D E F G188}189190/// Dynamically reconfigurable evaluation settings191#[derive(Trace)]192pub struct EvaluationSettings {193	/// Context initializer, which will be used for imports and everything194	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`195	pub context_initializer: TraceBox<dyn ContextInitializer>,196	/// Used to resolve file locations/contents197	pub import_resolver: TraceBox<dyn ImportResolver>,198}199impl Default for EvaluationSettings {200	fn default() -> Self {201		Self {202			context_initializer: tb!(()),203			import_resolver: tb!(DummyImportResolver),204		}205	}206}207208#[derive(Trace)]209struct FileData {210	string: Option<IStr>,211	bytes: Option<IBytes>,212	parsed: Option<LocExpr>,213	evaluated: Option<Val>,214215	evaluating: bool,216}217impl FileData {218	fn new_string(data: IStr) -> Self {219		Self {220			string: Some(data),221			bytes: None,222			parsed: None,223			evaluated: None,224			evaluating: false,225		}226	}227	fn new_bytes(data: IBytes) -> Self {228		Self {229			string: None,230			bytes: Some(data),231			parsed: None,232			evaluated: None,233			evaluating: false,234		}235	}236	pub(crate) fn get_string(&mut self) -> Option<IStr> {237		if self.string.is_none() {238			self.string = Some(239				self.bytes240					.as_ref()241					.expect("either string or bytes should be set")242					.clone()243					.cast_str()?,244			);245		}246		Some(self.string.clone().expect("just set"))247	}248}249250#[derive(Default, Trace)]251pub struct EvaluationStateInternals {252	/// Internal state253	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,254	/// Settings, safe to change at runtime255	settings: RefCell<EvaluationSettings>,256}257258/// Maintains stack trace and import resolution259#[derive(Default, Clone, Trace)]260pub struct State(Cc<EvaluationStateInternals>);261262impl State {263	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise264	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {265		let mut file_cache = self.file_cache();266		let mut file = file_cache.raw_entry_mut().from_key(&path);267268		let file = match file {269			RawEntryMut::Occupied(ref mut d) => d.get_mut(),270			RawEntryMut::Vacant(v) => {271				let data = self.settings().import_resolver.load_file_contents(&path)?;272				v.insert(273					path.clone(),274					FileData::new_string(275						std::str::from_utf8(&data)276							.map_err(|_| ImportBadFileUtf8(path.clone()))?277							.into(),278					),279				)280				.1281			}282		};283		Ok(file284			.get_string()285			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?)286	}287	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise288	pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {289		let mut file_cache = self.file_cache();290		let mut file = file_cache.raw_entry_mut().from_key(&path);291292		let file = match file {293			RawEntryMut::Occupied(ref mut d) => d.get_mut(),294			RawEntryMut::Vacant(v) => {295				let data = self.settings().import_resolver.load_file_contents(&path)?;296				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))297					.1298			}299		};300		if let Some(str) = &file.bytes {301			return Ok(str.clone());302		}303		if file.bytes.is_none() {304			file.bytes = Some(305				file.string306					.as_ref()307					.expect("either string or bytes should be set")308					.clone()309					.cast_bytes(),310			);311		}312		Ok(file.bytes.as_ref().expect("just set").clone())313	}314	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise315	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {316		let mut file_cache = self.file_cache();317		let mut file = file_cache.raw_entry_mut().from_key(&path);318319		let file = match file {320			RawEntryMut::Occupied(ref mut d) => d.get_mut(),321			RawEntryMut::Vacant(v) => {322				let data = self.settings().import_resolver.load_file_contents(&path)?;323				v.insert(324					path.clone(),325					FileData::new_string(326						std::str::from_utf8(&data)327							.map_err(|_| ImportBadFileUtf8(path.clone()))?328							.into(),329					),330				)331				.1332			}333		};334		if let Some(val) = &file.evaluated {335			return Ok(val.clone());336		}337		let code = file338			.get_string()339			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?;340		let file_name = Source::new(path.clone(), code.clone());341		if file.parsed.is_none() {342			file.parsed = Some(343				jrsonnet_parser::parse(344					&code,345					&ParserSettings {346						source: file_name.clone(),347					},348				)349				.map_err(|e| ImportSyntaxError {350					path: file_name.clone(),351					error: Box::new(e),352				})?,353			);354		}355		let parsed = file.parsed.as_ref().expect("just set").clone();356		if file.evaluating {357			throw!(InfiniteRecursionDetected)358		}359		file.evaluating = true;360		// Dropping file cache guard here, as evaluation may use this map too361		drop(file_cache);362		let res = evaluate(self.create_default_context(file_name), &parsed);363364		let mut file_cache = self.file_cache();365		let mut file = file_cache.raw_entry_mut().from_key(&path);366367		let RawEntryMut::Occupied(file) = &mut file else {368			unreachable!("this file was just here!")369		};370		let file = file.get_mut();371		file.evaluating = false;372		match res {373			Ok(v) => {374				file.evaluated = Some(v.clone());375				Ok(v)376			}377			Err(e) => Err(e),378		}379	}380381	/// Has same semantics as `import 'path'` called from `from` file382	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {383		let resolved = self.resolve_from(from, path)?;384		self.import_resolved(resolved)385	}386	pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {387		let resolved = self.resolve(path)?;388		self.import_resolved(resolved)389	}390391	/// Creates context with all passed global variables392	pub fn create_default_context(&self, source: Source) -> Context {393		let context_initializer = &self.settings().context_initializer;394		context_initializer.initialize(self.clone(), source)395	}396397	/// Creates context with all passed global variables, calling custom modifier398	pub fn create_default_context_with(399		&self,400		source: Source,401		context_initializer: impl ContextInitializer,402	) -> Context {403		let default_initializer = &self.settings().context_initializer;404		let mut builder = ContextBuilder::with_capacity(405			self.clone(),406			default_initializer.reserve_vars() + context_initializer.reserve_vars(),407		);408		default_initializer.populate(source.clone(), &mut builder);409		context_initializer.populate(source, &mut builder);410411		builder.build()412	}413414	/// Executes code creating a new stack frame415	pub fn push<T>(416		e: CallLocation<'_>,417		frame_desc: impl FnOnce() -> String,418		f: impl FnOnce() -> Result<T>,419	) -> Result<T> {420		let _guard = check_depth()?;421422		f().with_description_src(e, frame_desc)423	}424425	/// Executes code creating a new stack frame426	pub fn push_val(427		&self,428		e: &ExprLocation,429		frame_desc: impl FnOnce() -> String,430		f: impl FnOnce() -> Result<Val>,431	) -> Result<Val> {432		let _guard = check_depth()?;433434		f().with_description_src(e, frame_desc)435	}436	/// Executes code creating a new stack frame437	pub fn push_description<T>(438		frame_desc: impl FnOnce() -> String,439		f: impl FnOnce() -> Result<T>,440	) -> Result<T> {441		let _guard = check_depth()?;442443		f().with_description(frame_desc)444	}445}446447/// Internals448impl State {449	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {450		self.0.file_cache.borrow_mut()451	}452	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {453		self.0.settings.borrow()454	}455	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {456		self.0.settings.borrow_mut()457	}458	pub fn add_global(&self, name: IStr, value: Thunk<Val>) {459		#[derive(Trace)]460		struct GlobalsCtx {461			globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,462			inner: TraceBox<dyn ContextInitializer>,463		}464		impl ContextInitializer for GlobalsCtx {465			fn reserve_vars(&self) -> usize {466				self.inner.reserve_vars() + self.globals.borrow().len()467			}468			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {469				self.inner.populate(for_file, builder);470				for (name, val) in self.globals.borrow().iter() {471					builder.bind(name.clone(), val.clone());472				}473			}474475			fn as_any(&self) -> &dyn Any {476				self477			}478		}479		let mut settings = self.settings_mut();480		let initializer = &mut settings.context_initializer;481		if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {482			global.globals.borrow_mut().insert(name, value);483		} else {484			let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));485			settings.context_initializer = tb!(GlobalsCtx {486				globals: {487					let mut out = GcHashMap::with_capacity(1);488					out.insert(name, value);489					RefCell::new(out)490				},491				inner492			});493		}494	}495}496497#[derive(Trace)]498pub struct InitialUnderscore(pub Thunk<Val>);499impl ContextInitializer for InitialUnderscore {500	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {501		builder.bind("_".into(), self.0.clone());502	}503504	fn as_any(&self) -> &dyn Any {505		self506	}507}508509/// Raw methods evaluate passed values but don't perform TLA execution510impl State {511	/// Parses and evaluates the given snippet512	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {513		let code = code.into();514		let source = Source::new_virtual(name.into(), code.clone());515		let parsed = jrsonnet_parser::parse(516			&code,517			&ParserSettings {518				source: source.clone(),519			},520		)521		.map_err(|e| ImportSyntaxError {522			path: source.clone(),523			error: Box::new(e),524		})?;525		evaluate(self.create_default_context(source), &parsed)526	}527	/// Parses and evaluates the given snippet with custom context modifier528	pub fn evaluate_snippet_with(529		&self,530		name: impl Into<IStr>,531		code: impl Into<IStr>,532		context_initializer: impl ContextInitializer,533	) -> Result<Val> {534		let code = code.into();535		let source = Source::new_virtual(name.into(), code.clone());536		let parsed = jrsonnet_parser::parse(537			&code,538			&ParserSettings {539				source: source.clone(),540			},541		)542		.map_err(|e| ImportSyntaxError {543			path: source.clone(),544			error: Box::new(e),545		})?;546		evaluate(547			self.create_default_context_with(source, context_initializer),548			&parsed,549		)550	}551}552553/// Settings utilities554impl State {555	// Only panics in case of [`ImportResolver`] contract violation556	#[allow(clippy::missing_panics_doc)]557	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {558		self.import_resolver().resolve_from(from, path.as_ref())559	}560561	// Only panics in case of [`ImportResolver`] contract violation562	#[allow(clippy::missing_panics_doc)]563	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {564		self.import_resolver().resolve(path.as_ref())565	}566	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {567		Ref::map(self.settings(), |s| &*s.import_resolver)568	}569	pub fn set_import_resolver(&self, resolver: impl ImportResolver) {570		self.settings_mut().import_resolver = tb!(resolver);571	}572	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {573		Ref::map(self.settings(), |s| &*s.context_initializer)574	}575	pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {576		self.settings_mut().context_initializer = tb!(initializer);577	}578}