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

1//! jsonnet interpreter implementation2#![cfg_attr(feature = "nightly", feature(thread_local, type_alias_impl_trait))]34// For jrsonnet-macros5extern crate self as jrsonnet_evaluator;67mod arr;8#[cfg(feature = "async-import")]9pub mod async_import;10mod ctx;11mod dynamic;12pub mod error;13mod evaluate;14pub mod function;15pub mod gc;16mod import;17mod integrations;18pub mod manifest;19mod map;20mod obj;21pub mod stack;22pub mod stdlib;23mod tla;24pub mod trace;25pub mod typed;26pub mod val;2728use std::{29	any::Any,30	cell::{RefCell, RefMut},31	fmt::{self, Debug},32	path::Path,33};3435pub use ctx::*;36pub use dynamic::*;37pub use error::{Error, ErrorKind::*, Result, ResultExt};38pub use evaluate::*;39use function::CallLocation;40use gc::{GcHashMap, TraceBox};41use hashbrown::hash_map::RawEntryMut;42pub use import::*;43use jrsonnet_gcmodule::{Cc, Trace};44pub use jrsonnet_interner::{IBytes, IStr};45#[doc(hidden)]46pub use jrsonnet_macros;47pub use jrsonnet_parser as parser;48use jrsonnet_parser::{ExprLocation, LocExpr, ParserSettings, Source, SourcePath};49pub use obj::*;50use stack::check_depth;51pub use tla::apply_tla;52pub use val::{Thunk, Val};5354/// Thunk without bound `super`/`this`55/// object inheritance may be overriden multiple times, and will be fixed only on field read56pub trait Unbound: Trace {57	/// Type of value after object context is bound58	type Bound;59	/// Create value bound to specified object context60	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;61}6263/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code64/// Standard jsonnet fields are always unbound65#[derive(Clone, Trace)]66pub enum MaybeUnbound {67	/// Value needs to be bound to `this`/`super`68	Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),69	/// Value is object-independent70	Bound(Thunk<Val>),71}7273impl Debug for MaybeUnbound {74	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {75		write!(f, "MaybeUnbound")76	}77}78impl MaybeUnbound {79	/// Attach object context to value, if required80	pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {81		match self {82			Self::Unbound(v) => v.bind(sup, this),83			Self::Bound(v) => Ok(v.evaluate()?),84		}85	}86}8788/// During import, this trait will be called to create initial context for file.89/// It may initialize global variables, stdlib for example.90pub trait ContextInitializer: Trace {91	/// For which size the builder should be preallocated92	fn reserve_vars(&self) -> usize {93		094	}95	/// Initialize default file context.96	/// Has default implementation, which calls `populate`.97	/// Prefer to always implement `populate` instead.98	fn initialize(&self, state: State, for_file: Source) -> Context {99		let mut builder = ContextBuilder::with_capacity(state, self.reserve_vars());100		self.populate(for_file, &mut builder);101		builder.build()102	}103	/// For composability: extend builder. May panic if this initialization is not supported,104	/// and the context may only be created via `initialize`.105	fn populate(&self, for_file: Source, builder: &mut ContextBuilder);106	/// Allows upcasting from abstract to concrete context initializer.107	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.108	fn as_any(&self) -> &dyn Any;109}110111/// Context initializer which adds nothing.112impl ContextInitializer for () {113	fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}114	fn as_any(&self) -> &dyn Any {115		self116	}117}118119macro_rules! impl_context_initializer {120	($($gen:ident)*) => {121		#[allow(non_snake_case)]122		impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {123			fn reserve_vars(&self) -> usize {124				let mut out = 0;125				let ($($gen,)*) = self;126				$(out += $gen.reserve_vars();)*127				out128			}129			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {130				let ($($gen,)*) = self;131				$($gen.populate(for_file.clone(), builder);)*132			}133			fn as_any(&self) -> &dyn Any {134				self135			}136		}137	};138	($($cur:ident)* @ $c:ident $($rest:ident)*) => {139		impl_context_initializer!($($cur)*);140		impl_context_initializer!($($cur)* $c @ $($rest)*);141	};142	($($cur:ident)* @) => {143		impl_context_initializer!($($cur)*);144	}145}146impl_context_initializer! {147	A @ B C D E F G148}149150#[derive(Trace)]151struct FileData {152	string: Option<IStr>,153	bytes: Option<IBytes>,154	parsed: Option<LocExpr>,155	evaluated: Option<Val>,156157	evaluating: bool,158}159impl FileData {160	fn new_string(data: IStr) -> Self {161		Self {162			string: Some(data),163			bytes: None,164			parsed: None,165			evaluated: None,166			evaluating: false,167		}168	}169	fn new_bytes(data: IBytes) -> Self {170		Self {171			string: None,172			bytes: Some(data),173			parsed: None,174			evaluated: None,175			evaluating: false,176		}177	}178	pub(crate) fn get_string(&mut self) -> Option<IStr> {179		if self.string.is_none() {180			self.string = Some(181				self.bytes182					.as_ref()183					.expect("either string or bytes should be set")184					.clone()185					.cast_str()?,186			);187		}188		Some(self.string.clone().expect("just set"))189	}190}191192#[derive(Trace)]193pub struct EvaluationStateInternals {194	/// Internal state195	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,196	/// Context initializer, which will be used for imports and everything197	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`198	context_initializer: TraceBox<dyn ContextInitializer>,199	/// Used to resolve file locations/contents200	import_resolver: TraceBox<dyn ImportResolver>,201}202203/// Maintains stack trace and import resolution204#[derive(Clone, Trace)]205pub struct State(Cc<EvaluationStateInternals>);206207impl State {208	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise209	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {210		let mut file_cache = self.file_cache();211		let mut file = file_cache.raw_entry_mut().from_key(&path);212213		let file = match file {214			RawEntryMut::Occupied(ref mut d) => d.get_mut(),215			RawEntryMut::Vacant(v) => {216				let data = self.import_resolver().load_file_contents(&path)?;217				v.insert(218					path.clone(),219					FileData::new_string(220						std::str::from_utf8(&data)221							.map_err(|_| ImportBadFileUtf8(path.clone()))?222							.into(),223					),224				)225				.1226			}227		};228		Ok(file229			.get_string()230			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?)231	}232	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise233	pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {234		let mut file_cache = self.file_cache();235		let mut file = file_cache.raw_entry_mut().from_key(&path);236237		let file = match file {238			RawEntryMut::Occupied(ref mut d) => d.get_mut(),239			RawEntryMut::Vacant(v) => {240				let data = self.import_resolver().load_file_contents(&path)?;241				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))242					.1243			}244		};245		if let Some(str) = &file.bytes {246			return Ok(str.clone());247		}248		if file.bytes.is_none() {249			file.bytes = Some(250				file.string251					.as_ref()252					.expect("either string or bytes should be set")253					.clone()254					.cast_bytes(),255			);256		}257		Ok(file.bytes.as_ref().expect("just set").clone())258	}259	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise260	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {261		let mut file_cache = self.file_cache();262		let mut file = file_cache.raw_entry_mut().from_key(&path);263264		let file = match file {265			RawEntryMut::Occupied(ref mut d) => d.get_mut(),266			RawEntryMut::Vacant(v) => {267				let data = self.import_resolver().load_file_contents(&path)?;268				v.insert(269					path.clone(),270					FileData::new_string(271						std::str::from_utf8(&data)272							.map_err(|_| ImportBadFileUtf8(path.clone()))?273							.into(),274					),275				)276				.1277			}278		};279		if let Some(val) = &file.evaluated {280			return Ok(val.clone());281		}282		let code = file283			.get_string()284			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?;285		let file_name = Source::new(path.clone(), code.clone());286		if file.parsed.is_none() {287			file.parsed = Some(288				jrsonnet_parser::parse(289					&code,290					&ParserSettings {291						source: file_name.clone(),292					},293				)294				.map_err(|e| ImportSyntaxError {295					path: file_name.clone(),296					error: Box::new(e),297				})?,298			);299		}300		let parsed = file.parsed.as_ref().expect("just set").clone();301		if file.evaluating {302			bail!(InfiniteRecursionDetected)303		}304		file.evaluating = true;305		// Dropping file cache guard here, as evaluation may use this map too306		drop(file_cache);307		let res = evaluate(self.create_default_context(file_name), &parsed);308309		let mut file_cache = self.file_cache();310		let mut file = file_cache.raw_entry_mut().from_key(&path);311312		let RawEntryMut::Occupied(file) = &mut file else {313			unreachable!("this file was just here!")314		};315		let file = file.get_mut();316		file.evaluating = false;317		match res {318			Ok(v) => {319				file.evaluated = Some(v.clone());320				Ok(v)321			}322			Err(e) => Err(e),323		}324	}325326	/// Has same semantics as `import 'path'` called from `from` file327	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {328		let resolved = self.resolve_from(from, path)?;329		self.import_resolved(resolved)330	}331	pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {332		let resolved = self.resolve(path)?;333		self.import_resolved(resolved)334	}335336	/// Creates context with all passed global variables337	pub fn create_default_context(&self, source: Source) -> Context {338		self.context_initializer().initialize(self.clone(), source)339	}340341	/// Creates context with all passed global variables, calling custom modifier342	pub fn create_default_context_with(343		&self,344		source: Source,345		context_initializer: impl ContextInitializer,346	) -> Context {347		let default_initializer = self.context_initializer();348		let mut builder = ContextBuilder::with_capacity(349			self.clone(),350			default_initializer.reserve_vars() + context_initializer.reserve_vars(),351		);352		default_initializer.populate(source.clone(), &mut builder);353		context_initializer.populate(source, &mut builder);354355		builder.build()356	}357358	/// Executes code creating a new stack frame359	pub fn push<T>(360		e: CallLocation<'_>,361		frame_desc: impl FnOnce() -> String,362		f: impl FnOnce() -> Result<T>,363	) -> Result<T> {364		let _guard = check_depth()?;365366		f().with_description_src(e, frame_desc)367	}368369	/// Executes code creating a new stack frame370	pub fn push_val(371		&self,372		e: &ExprLocation,373		frame_desc: impl FnOnce() -> String,374		f: impl FnOnce() -> Result<Val>,375	) -> Result<Val> {376		let _guard = check_depth()?;377378		f().with_description_src(e, frame_desc)379	}380	/// Executes code creating a new stack frame381	pub fn push_description<T>(382		frame_desc: impl FnOnce() -> String,383		f: impl FnOnce() -> Result<T>,384	) -> Result<T> {385		let _guard = check_depth()?;386387		f().with_description(frame_desc)388	}389}390391/// Internals392impl State {393	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {394		self.0.file_cache.borrow_mut()395	}396}397398#[derive(Trace)]399pub struct InitialUnderscore(pub Thunk<Val>);400impl ContextInitializer for InitialUnderscore {401	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {402		builder.bind("_", self.0.clone());403	}404405	fn as_any(&self) -> &dyn Any {406		self407	}408}409410/// Raw methods evaluate passed values but don't perform TLA execution411impl State {412	/// Parses and evaluates the given snippet413	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {414		let code = code.into();415		let source = Source::new_virtual(name.into(), code.clone());416		let parsed = jrsonnet_parser::parse(417			&code,418			&ParserSettings {419				source: source.clone(),420			},421		)422		.map_err(|e| ImportSyntaxError {423			path: source.clone(),424			error: Box::new(e),425		})?;426		evaluate(self.create_default_context(source), &parsed)427	}428	/// Parses and evaluates the given snippet with custom context modifier429	pub fn evaluate_snippet_with(430		&self,431		name: impl Into<IStr>,432		code: impl Into<IStr>,433		context_initializer: impl ContextInitializer,434	) -> Result<Val> {435		let code = code.into();436		let source = Source::new_virtual(name.into(), code.clone());437		let parsed = jrsonnet_parser::parse(438			&code,439			&ParserSettings {440				source: source.clone(),441			},442		)443		.map_err(|e| ImportSyntaxError {444			path: source.clone(),445			error: Box::new(e),446		})?;447		evaluate(448			self.create_default_context_with(source, context_initializer),449			&parsed,450		)451	}452}453454/// Settings utilities455impl State {456	// Only panics in case of [`ImportResolver`] contract violation457	#[allow(clippy::missing_panics_doc)]458	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {459		self.import_resolver().resolve_from(from, path.as_ref())460	}461462	// Only panics in case of [`ImportResolver`] contract violation463	#[allow(clippy::missing_panics_doc)]464	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {465		self.import_resolver().resolve(path.as_ref())466	}467	pub fn import_resolver(&self) -> &dyn ImportResolver {468		&*self.0.import_resolver469	}470	pub fn context_initializer(&self) -> &dyn ContextInitializer {471		&*self.0.context_initializer472	}473}474475impl State {476	pub fn builder() -> StateBuilder {477		StateBuilder::default()478	}479}480481impl Default for State {482	fn default() -> Self {483		Self::builder().build()484	}485}486487#[derive(Default)]488pub struct StateBuilder {489	import_resolver: Option<TraceBox<dyn ImportResolver>>,490	context_initializer: Option<TraceBox<dyn ContextInitializer>>,491}492impl StateBuilder {493	pub fn import_resolver(&mut self, import_resolver: impl ImportResolver) -> &mut Self {494		let _ = self.import_resolver.insert(tb!(import_resolver));495		self496	}497	pub fn context_initializer(498		&mut self,499		context_initializer: impl ContextInitializer,500	) -> &mut Self {501		let _ = self.context_initializer.insert(tb!(context_initializer));502		self503	}504	pub fn build(mut self) -> State {505		State(Cc::new(EvaluationStateInternals {506			file_cache: RefCell::new(GcHashMap::new()),507			context_initializer: self.context_initializer.take().unwrap_or_else(|| tb!(())),508			import_resolver: self509				.import_resolver510				.take()511				.unwrap_or_else(|| tb!(DummyImportResolver)),512		}))513	}514}