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

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	// false positive for IStr type. There is an configuration option for45	// such cases, but it doesn't work:46	// https://github.com/rust-lang/rust-clippy/issues/980147	clippy::mutable_key_type,48	// false positives49	clippy::redundant_pub_crate,50	// Sometimes code is fancier without that51	clippy::manual_let_else,52)]5354// For jrsonnet-macros55extern crate self as jrsonnet_evaluator;5657mod arr;58#[cfg(feature = "async-import")]59pub mod async_import;60mod ctx;61mod dynamic;62pub mod error;63mod evaluate;64pub mod function;65pub mod gc;66mod import;67mod integrations;68pub mod manifest;69mod map;70mod obj;71pub mod stack;72pub mod stdlib;73mod tla;74pub mod trace;75pub mod typed;76pub mod val;7778use std::{79	any::Any,80	cell::{Ref, RefCell, RefMut},81	fmt::{self, Debug},82	path::Path,83};8485pub use ctx::*;86pub use dynamic::*;87pub use error::{Error, ErrorKind::*, Result, ResultExt};88pub use evaluate::*;89use function::CallLocation;90use gc::{GcHashMap, TraceBox};91use hashbrown::hash_map::RawEntryMut;92pub use import::*;93use jrsonnet_gcmodule::{Cc, Trace};94pub use jrsonnet_interner::{IBytes, IStr};95#[doc(hidden)]96pub use jrsonnet_macros;97pub use jrsonnet_parser as parser;98use jrsonnet_parser::*;99pub use obj::*;100use stack::check_depth;101pub use tla::apply_tla;102pub use val::{Thunk, Val};103104/// Thunk without bound `super`/`this`105/// object inheritance may be overriden multiple times, and will be fixed only on field read106pub trait Unbound: Trace {107	/// Type of value after object context is bound108	type Bound;109	/// Create value bound to specified object context110	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;111}112113/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code114/// Standard jsonnet fields are always unbound115#[derive(Clone, Trace)]116pub enum MaybeUnbound {117	/// Value needs to be bound to `this`/`super`118	Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),119	/// Value is object-independent120	Bound(Thunk<Val>),121}122123impl Debug for MaybeUnbound {124	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {125		write!(f, "MaybeUnbound")126	}127}128impl MaybeUnbound {129	/// Attach object context to value, if required130	pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {131		match self {132			Self::Unbound(v) => v.bind(sup, this),133			Self::Bound(v) => Ok(v.evaluate()?),134		}135	}136}137138/// During import, this trait will be called to create initial context for file.139/// It may initialize global variables, stdlib for example.140pub trait ContextInitializer: Trace {141	/// For which size the builder should be preallocated142	fn reserve_vars(&self) -> usize {143		0144	}145	/// Initialize default file context.146	/// Has default implementation, which calls `populate`.147	/// Prefer to always implement `populate` instead.148	fn initialize(&self, state: State, for_file: Source) -> Context {149		let mut builder = ContextBuilder::with_capacity(state, self.reserve_vars());150		self.populate(for_file, &mut builder);151		builder.build()152	}153	/// For composability: extend builder. May panic if this initialization is not supported,154	/// and the context may only be created via `initialize`.155	fn populate(&self, for_file: Source, builder: &mut ContextBuilder);156	/// Allows upcasting from abstract to concrete context initializer.157	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.158	fn as_any(&self) -> &dyn Any;159}160161/// Context initializer which adds nothing.162impl ContextInitializer for () {163	fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}164	fn as_any(&self) -> &dyn Any {165		self166	}167}168169macro_rules! impl_context_initializer {170	($($gen:ident)*) => {171		#[allow(non_snake_case)]172		impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {173			fn reserve_vars(&self) -> usize {174				let mut out = 0;175				let ($($gen,)*) = self;176				$(out += $gen.reserve_vars();)*177				out178			}179			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {180				let ($($gen,)*) = self;181				$($gen.populate(for_file.clone(), builder);)*182			}183			fn as_any(&self) -> &dyn Any {184				self185			}186		}187	};188	($($cur:ident)* @ $c:ident $($rest:ident)*) => {189		impl_context_initializer!($($cur)*);190		impl_context_initializer!($($cur)* $c @ $($rest)*);191	};192	($($cur:ident)* @) => {193		impl_context_initializer!($($cur)*);194	}195}196impl_context_initializer! {197	A @ B C D E F G198}199200/// Dynamically reconfigurable evaluation settings201#[derive(Trace)]202pub struct EvaluationSettings {203	/// Context initializer, which will be used for imports and everything204	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`205	pub context_initializer: TraceBox<dyn ContextInitializer>,206	/// Used to resolve file locations/contents207	pub import_resolver: TraceBox<dyn ImportResolver>,208}209impl Default for EvaluationSettings {210	fn default() -> Self {211		Self {212			context_initializer: tb!(()),213			import_resolver: tb!(DummyImportResolver),214		}215	}216}217218#[derive(Trace)]219struct FileData {220	string: Option<IStr>,221	bytes: Option<IBytes>,222	parsed: Option<LocExpr>,223	evaluated: Option<Val>,224225	evaluating: bool,226}227impl FileData {228	fn new_string(data: IStr) -> Self {229		Self {230			string: Some(data),231			bytes: None,232			parsed: None,233			evaluated: None,234			evaluating: false,235		}236	}237	fn new_bytes(data: IBytes) -> Self {238		Self {239			string: None,240			bytes: Some(data),241			parsed: None,242			evaluated: None,243			evaluating: false,244		}245	}246	pub(crate) fn get_string(&mut self) -> Option<IStr> {247		if self.string.is_none() {248			self.string = Some(249				self.bytes250					.as_ref()251					.expect("either string or bytes should be set")252					.clone()253					.cast_str()?,254			);255		}256		Some(self.string.clone().expect("just set"))257	}258}259260#[derive(Default, Trace)]261pub struct EvaluationStateInternals {262	/// Internal state263	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,264	/// Settings, safe to change at runtime265	settings: RefCell<EvaluationSettings>,266}267268/// Maintains stack trace and import resolution269#[derive(Default, Clone, Trace)]270pub struct State(Cc<EvaluationStateInternals>);271272impl State {273	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise274	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {275		let mut file_cache = self.file_cache();276		let mut file = file_cache.raw_entry_mut().from_key(&path);277278		let file = match file {279			RawEntryMut::Occupied(ref mut d) => d.get_mut(),280			RawEntryMut::Vacant(v) => {281				let data = self.settings().import_resolver.load_file_contents(&path)?;282				v.insert(283					path.clone(),284					FileData::new_string(285						std::str::from_utf8(&data)286							.map_err(|_| ImportBadFileUtf8(path.clone()))?287							.into(),288					),289				)290				.1291			}292		};293		Ok(file294			.get_string()295			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?)296	}297	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise298	pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {299		let mut file_cache = self.file_cache();300		let mut file = file_cache.raw_entry_mut().from_key(&path);301302		let file = match file {303			RawEntryMut::Occupied(ref mut d) => d.get_mut(),304			RawEntryMut::Vacant(v) => {305				let data = self.settings().import_resolver.load_file_contents(&path)?;306				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))307					.1308			}309		};310		if let Some(str) = &file.bytes {311			return Ok(str.clone());312		}313		if file.bytes.is_none() {314			file.bytes = Some(315				file.string316					.as_ref()317					.expect("either string or bytes should be set")318					.clone()319					.cast_bytes(),320			);321		}322		Ok(file.bytes.as_ref().expect("just set").clone())323	}324	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise325	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {326		let mut file_cache = self.file_cache();327		let mut file = file_cache.raw_entry_mut().from_key(&path);328329		let file = match file {330			RawEntryMut::Occupied(ref mut d) => d.get_mut(),331			RawEntryMut::Vacant(v) => {332				let data = self.settings().import_resolver.load_file_contents(&path)?;333				v.insert(334					path.clone(),335					FileData::new_string(336						std::str::from_utf8(&data)337							.map_err(|_| ImportBadFileUtf8(path.clone()))?338							.into(),339					),340				)341				.1342			}343		};344		if let Some(val) = &file.evaluated {345			return Ok(val.clone());346		}347		let code = file348			.get_string()349			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?;350		let file_name = Source::new(path.clone(), code.clone());351		if file.parsed.is_none() {352			file.parsed = Some(353				jrsonnet_parser::parse(354					&code,355					&ParserSettings {356						source: file_name.clone(),357					},358				)359				.map_err(|e| ImportSyntaxError {360					path: file_name.clone(),361					error: Box::new(e),362				})?,363			);364		}365		let parsed = file.parsed.as_ref().expect("just set").clone();366		if file.evaluating {367			bail!(InfiniteRecursionDetected)368		}369		file.evaluating = true;370		// Dropping file cache guard here, as evaluation may use this map too371		drop(file_cache);372		let res = evaluate(self.create_default_context(file_name), &parsed);373374		let mut file_cache = self.file_cache();375		let mut file = file_cache.raw_entry_mut().from_key(&path);376377		let RawEntryMut::Occupied(file) = &mut file else {378			unreachable!("this file was just here!")379		};380		let file = file.get_mut();381		file.evaluating = false;382		match res {383			Ok(v) => {384				file.evaluated = Some(v.clone());385				Ok(v)386			}387			Err(e) => Err(e),388		}389	}390391	/// Has same semantics as `import 'path'` called from `from` file392	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {393		let resolved = self.resolve_from(from, path)?;394		self.import_resolved(resolved)395	}396	pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {397		let resolved = self.resolve(path)?;398		self.import_resolved(resolved)399	}400401	/// Creates context with all passed global variables402	pub fn create_default_context(&self, source: Source) -> Context {403		let context_initializer = &self.settings().context_initializer;404		context_initializer.initialize(self.clone(), source)405	}406407	/// Creates context with all passed global variables, calling custom modifier408	pub fn create_default_context_with(409		&self,410		source: Source,411		context_initializer: impl ContextInitializer,412	) -> Context {413		let default_initializer = &self.settings().context_initializer;414		let mut builder = ContextBuilder::with_capacity(415			self.clone(),416			default_initializer.reserve_vars() + context_initializer.reserve_vars(),417		);418		default_initializer.populate(source.clone(), &mut builder);419		context_initializer.populate(source, &mut builder);420421		builder.build()422	}423424	/// Executes code creating a new stack frame425	pub fn push<T>(426		e: CallLocation<'_>,427		frame_desc: impl FnOnce() -> String,428		f: impl FnOnce() -> Result<T>,429	) -> Result<T> {430		let _guard = check_depth()?;431432		f().with_description_src(e, frame_desc)433	}434435	/// Executes code creating a new stack frame436	pub fn push_val(437		&self,438		e: &ExprLocation,439		frame_desc: impl FnOnce() -> String,440		f: impl FnOnce() -> Result<Val>,441	) -> Result<Val> {442		let _guard = check_depth()?;443444		f().with_description_src(e, frame_desc)445	}446	/// Executes code creating a new stack frame447	pub fn push_description<T>(448		frame_desc: impl FnOnce() -> String,449		f: impl FnOnce() -> Result<T>,450	) -> Result<T> {451		let _guard = check_depth()?;452453		f().with_description(frame_desc)454	}455}456457/// Internals458impl State {459	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {460		self.0.file_cache.borrow_mut()461	}462	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {463		self.0.settings.borrow()464	}465	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {466		self.0.settings.borrow_mut()467	}468	pub fn add_global(&self, name: IStr, value: Thunk<Val>) {469		#[derive(Trace)]470		struct GlobalsCtx {471			globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,472			inner: TraceBox<dyn ContextInitializer>,473		}474		impl ContextInitializer for GlobalsCtx {475			fn reserve_vars(&self) -> usize {476				self.inner.reserve_vars() + self.globals.borrow().len()477			}478			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {479				self.inner.populate(for_file, builder);480				for (name, val) in self.globals.borrow().iter() {481					builder.bind(name.clone(), val.clone());482				}483			}484485			fn as_any(&self) -> &dyn Any {486				self487			}488		}489		let mut settings = self.settings_mut();490		let initializer = &mut settings.context_initializer;491		if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {492			global.globals.borrow_mut().insert(name, value);493		} else {494			let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));495			settings.context_initializer = tb!(GlobalsCtx {496				globals: {497					let mut out = GcHashMap::with_capacity(1);498					out.insert(name, value);499					RefCell::new(out)500				},501				inner502			});503		}504	}505}506507#[derive(Trace)]508pub struct InitialUnderscore(pub Thunk<Val>);509impl ContextInitializer for InitialUnderscore {510	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {511		builder.bind("_", self.0.clone());512	}513514	fn as_any(&self) -> &dyn Any {515		self516	}517}518519/// Raw methods evaluate passed values but don't perform TLA execution520impl State {521	/// Parses and evaluates the given snippet522	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {523		let code = code.into();524		let source = Source::new_virtual(name.into(), code.clone());525		let parsed = jrsonnet_parser::parse(526			&code,527			&ParserSettings {528				source: source.clone(),529			},530		)531		.map_err(|e| ImportSyntaxError {532			path: source.clone(),533			error: Box::new(e),534		})?;535		evaluate(self.create_default_context(source), &parsed)536	}537	/// Parses and evaluates the given snippet with custom context modifier538	pub fn evaluate_snippet_with(539		&self,540		name: impl Into<IStr>,541		code: impl Into<IStr>,542		context_initializer: impl ContextInitializer,543	) -> Result<Val> {544		let code = code.into();545		let source = Source::new_virtual(name.into(), code.clone());546		let parsed = jrsonnet_parser::parse(547			&code,548			&ParserSettings {549				source: source.clone(),550			},551		)552		.map_err(|e| ImportSyntaxError {553			path: source.clone(),554			error: Box::new(e),555		})?;556		evaluate(557			self.create_default_context_with(source, context_initializer),558			&parsed,559		)560	}561}562563/// Settings utilities564impl State {565	// Only panics in case of [`ImportResolver`] contract violation566	#[allow(clippy::missing_panics_doc)]567	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {568		self.import_resolver().resolve_from(from, path.as_ref())569	}570571	// Only panics in case of [`ImportResolver`] contract violation572	#[allow(clippy::missing_panics_doc)]573	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {574		self.import_resolver().resolve(path.as_ref())575	}576	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {577		Ref::map(self.settings(), |s| &*s.import_resolver)578	}579	pub fn set_import_resolver(&self, resolver: impl ImportResolver) {580		self.settings_mut().import_resolver = tb!(resolver);581	}582	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {583		Ref::map(self.settings(), |s| &*s.context_initializer)584	}585	pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {586		self.settings_mut().context_initializer = tb!(initializer);587	}588}