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

1//! jsonnet interpreter implementation2#![cfg_attr(nightly, feature(thread_local, type_alias_impl_trait))]34// For jrsonnet-macros5extern crate self as jrsonnet_evaluator;67mod arr;8// pub mod async_import;9mod ctx;10mod dynamic;11pub mod error;12mod evaluate;13pub mod function;14pub mod gc;15mod import;16mod integrations;17pub mod manifest;18mod map;19mod obj;20pub mod stack;21pub mod stdlib;22pub mod tla;23pub mod trace;24pub mod typed;25pub mod val;2627use std::{28	any::Any,29	cell::{RefCell, RefMut},30	clone::Clone,31	collections::hash_map::Entry,32	fmt::{self, Debug},33	marker::PhantomData,34	rc::Rc,35};3637pub use ctx::*;38pub use dynamic::*;39pub use error::{Error, ErrorKind::*, Result, ResultExt};40pub use evaluate::*;41use function::CallLocation;42pub use import::*;43use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};44pub use jrsonnet_interner::{IBytes, IStr};45pub use jrsonnet_ir as parser;46use jrsonnet_ir::{Expr, Source, SourcePath};47#[doc(hidden)]48pub use jrsonnet_macros;49use jrsonnet_peg_parser::ParserSettings;50pub use obj::*;51pub use rustc_hash;52use rustc_hash::FxHashMap;53use stack::check_depth;54pub use tla::apply_tla;55pub use val::{Thunk, Val};5657use crate::gc::WithCapacityExt as _;5859cc_dyn!(60	#[derive(Clone)]61	CcUnbound<V>,62	Unbound<Bound = V>63);6465/// Thunk without bound `super`/`this`66/// object inheritance may be overriden multiple times, and will be fixed only on field read67pub trait Unbound: Trace {68	/// Type of value after object context is bound69	type Bound;70	/// Create value bound to specified object context71	fn bind(&self, sup_this: SupThis) -> Result<Self::Bound>;72}7374/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code75/// Standard jsonnet fields are always unbound76#[derive(Clone, Trace)]77pub enum MaybeUnbound {78	/// Value needs to be bound to `this`/`super`79	Unbound(CcUnbound<Val>),80	/// Value is object-independent81	Bound(Thunk<Val>),82}8384impl Debug for MaybeUnbound {85	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {86		write!(f, "MaybeUnbound")87	}88}89impl MaybeUnbound {90	/// Attach object context to value, if required91	pub fn evaluate(&self, sup_this: SupThis) -> Result<Val> {92		match self {93			Self::Unbound(v) => v.0.bind(sup_this),94			Self::Bound(v) => Ok(v.evaluate()?),95		}96	}97}9899cc_dyn!(CcContextInitializer, ContextInitializer);100101/// During import, this trait will be called to create initial context for file.102/// It may initialize global variables, stdlib for example.103pub trait ContextInitializer: Trace {104	/// For which size the builder should be preallocated105	fn reserve_vars(&self) -> usize {106		0107	}108	/// Initialize default file context.109	/// Has default implementation, which calls `populate`.110	/// Prefer to always implement `populate` instead.111	fn initialize(&self, for_file: Source) -> Context {112		let mut builder = ContextBuilder::with_capacity(self.reserve_vars());113		self.populate(for_file, &mut builder);114		builder.build()115	}116	/// For composability: extend builder. May panic if this initialization is not supported,117	/// and the context may only be created via `initialize`.118	fn populate(&self, for_file: Source, builder: &mut ContextBuilder);119	/// Allows upcasting from abstract to concrete context initializer.120	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.121	fn as_any(&self) -> &dyn Any;122}123124/// Context initializer which adds nothing.125impl ContextInitializer for () {126	fn populate(&self, _for_file: Source, _builder: &mut ContextBuilder) {}127	fn as_any(&self) -> &dyn Any {128		self129	}130}131132impl<T> ContextInitializer for Option<T>133where134	T: ContextInitializer,135{136	fn initialize(&self, for_file: Source) -> Context {137		if let Some(ctx) = self {138			ctx.initialize(for_file)139		} else {140			().initialize(for_file)141		}142	}143144	fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {145		if let Some(ctx) = self {146			ctx.populate(for_file, builder);147		}148	}149150	fn as_any(&self) -> &dyn Any {151		self152	}153}154155macro_rules! impl_context_initializer {156	($($gen:ident)*) => {157		#[allow(non_snake_case)]158		impl<$($gen: ContextInitializer + Trace,)*> ContextInitializer for ($($gen,)*) {159			fn reserve_vars(&self) -> usize {160				let mut out = 0;161				let ($($gen,)*) = self;162				$(out += $gen.reserve_vars();)*163				out164			}165			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {166				let ($($gen,)*) = self;167				$($gen.populate(for_file.clone(), builder);)*168			}169			fn as_any(&self) -> &dyn Any {170				self171			}172		}173	};174	($($cur:ident)* @ $c:ident $($rest:ident)*) => {175		impl_context_initializer!($($cur)*);176		impl_context_initializer!($($cur)* $c @ $($rest)*);177	};178	($($cur:ident)* @) => {179		impl_context_initializer!($($cur)*);180	}181}182impl_context_initializer! {183	A @ B C D E F G184}185186#[derive(Trace)]187struct FileData {188	string: Option<IStr>,189	bytes: Option<IBytes>,190	parsed: Option<Rc<Expr>>,191	evaluated: Option<Val>,192193	evaluating: bool,194}195impl FileData {196	fn new_string(data: IStr) -> Self {197		Self {198			string: Some(data),199			bytes: None,200			parsed: None,201			evaluated: None,202			evaluating: false,203		}204	}205	fn new_bytes(data: IBytes) -> Self {206		Self {207			string: None,208			bytes: Some(data),209			parsed: None,210			evaluated: None,211			evaluating: false,212		}213	}214	pub(crate) fn get_string(&mut self) -> Option<IStr> {215		if self.string.is_none() {216			self.string = Some(217				self.bytes218					.as_ref()219					.expect("either string or bytes should be set")220					.clone()221					.cast_str()?,222			);223		}224		Some(self.string.clone().expect("just set"))225	}226}227228#[derive(Trace)]229pub struct EvaluationStateInternals {230	/// Internal state231	file_cache: RefCell<FxHashMap<SourcePath, FileData>>,232	/// Context initializer, which will be used for imports and everything233	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`234	context_initializer: CcContextInitializer,235	/// Used to resolve file locations/contents236	import_resolver: Rc<dyn ImportResolver>,237}238239/// Maintains stack trace and import resolution240#[derive(Clone, Trace)]241pub struct State(Cc<EvaluationStateInternals>);242243thread_local! {244	pub static DEFAULT_STATE: State = State::builder().build();245	pub static STATE: RefCell<Option<State>> = const {RefCell::new(None)};246}247pub struct StateEnterGuard(PhantomData<()>);248impl Drop for StateEnterGuard {249	fn drop(&mut self) {250		STATE.with_borrow_mut(|v| *v = None);251	}252}253254pub fn with_state<V>(v: impl FnOnce(State) -> V) -> V {255	if let Some(state) = STATE.with_borrow(Clone::clone) {256		v(state)257	} else {258		let s = DEFAULT_STATE.with(Clone::clone);259		v(s)260	}261}262263impl State {264	pub fn enter(&self) -> StateEnterGuard {265		self.try_enter().expect("entered state already exists")266	}267	pub fn try_enter(&self) -> Option<StateEnterGuard> {268		STATE.with_borrow_mut(|v| {269			if v.is_none() {270				*v = Some(self.clone());271				Some(StateEnterGuard(PhantomData))272			} else {273				None274			}275		})276	}277	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise278	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {279		let mut file_cache = self.file_cache();280		let mut file = file_cache.entry(path.clone());281282		let file = match file {283			Entry::Occupied(ref mut d) => d.get_mut(),284			Entry::Vacant(v) => {285				let data = self.import_resolver().load_file_contents(&path)?;286				v.insert(FileData::new_string(287					std::str::from_utf8(&data)288						.map_err(|_| ImportBadFileUtf8(path.clone()))?289						.into(),290				))291			}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.entry(path.clone());301302		let file = match file {303			Entry::Occupied(ref mut d) => d.get_mut(),304			Entry::Vacant(v) => {305				let data = self.import_resolver().load_file_contents(&path)?;306				v.insert(FileData::new_bytes(data.as_slice().into()))307			}308		};309		if let Some(str) = &file.bytes {310			return Ok(str.clone());311		}312		if file.bytes.is_none() {313			file.bytes = Some(314				file.string315					.as_ref()316					.expect("either string or bytes should be set")317					.clone()318					.cast_bytes(),319			);320		}321		Ok(file.bytes.as_ref().expect("just set").clone())322	}323	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise324	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {325		let mut file_cache = self.file_cache();326		let mut file = file_cache.entry(path.clone());327328		let file = match file {329			Entry::Occupied(ref mut d) => d.get_mut(),330			Entry::Vacant(v) => {331				let data = self.import_resolver().load_file_contents(&path)?;332				v.insert(FileData::new_string(333					std::str::from_utf8(&data)334						.map_err(|_| ImportBadFileUtf8(path.clone()))?335						.into(),336				))337			}338		};339		if let Some(val) = &file.evaluated {340			return Ok(val.clone());341		}342		let code = file343			.get_string()344			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?;345		let file_name = Source::new(path.clone(), code.clone());346		if file.parsed.is_none() {347			file.parsed = Some(348				jrsonnet_peg_parser::parse(349					&code,350					&ParserSettings {351						source: file_name.clone(),352					},353				)354				.map(Rc::new)355				.map_err(|e| ImportSyntaxError {356					path: file_name.clone(),357					error: Box::new(e),358				})?,359			);360		}361		let parsed = file.parsed.as_ref().expect("just set").clone();362		if file.evaluating {363			bail!(InfiniteRecursionDetected)364		}365		file.evaluating = true;366		// Dropping file cache guard here, as evaluation may use this map too367		drop(file_cache);368		let res = evaluate(self.create_default_context(file_name), &parsed);369370		let mut file_cache = self.file_cache();371		let mut file = file_cache.entry(path);372373		let Entry::Occupied(file) = &mut file else {374			unreachable!("this file was just here")375		};376		let file = file.get_mut();377		file.evaluating = false;378		match res {379			Ok(v) => {380				file.evaluated = Some(v.clone());381				Ok(v)382			}383			Err(e) => Err(e),384		}385	}386387	/// Has same semantics as `import 'path'` called from `from` file388	pub fn import_from(&self, from: &SourcePath, path: impl AsPathLike) -> Result<Val> {389		let resolved = self.resolve_from(from, &path)?;390		self.import_resolved(resolved)391	}392	pub fn import(&self, path: impl AsPathLike) -> Result<Val> {393		let resolved = self.resolve_from_default(&path)?;394		self.import_resolved(resolved)395	}396397	/// Creates context with all passed global variables398	pub fn create_default_context(&self, source: Source) -> Context {399		self.context_initializer().initialize(source)400	}401402	/// Creates context with all passed global variables, calling custom modifier403	pub fn create_default_context_with(404		&self,405		source: Source,406		context_initializer: impl ContextInitializer,407	) -> Context {408		let default_initializer = self.context_initializer();409		let mut builder = ContextBuilder::with_capacity(410			default_initializer.reserve_vars() + context_initializer.reserve_vars(),411		);412		default_initializer.populate(source.clone(), &mut builder);413		context_initializer.populate(source, &mut builder);414415		builder.build()416	}417}418419/// Internals420impl State {421	fn file_cache(&self) -> RefMut<'_, FxHashMap<SourcePath, FileData>> {422		self.0.file_cache.borrow_mut()423	}424}425/// Executes code creating a new stack frame, to be replaced with try{}426pub fn in_frame<T>(427	e: CallLocation<'_>,428	frame_desc: impl FnOnce() -> String,429	f: impl FnOnce() -> Result<T>,430) -> Result<T> {431	let _guard = check_depth()?;432433	f().with_description_src(e, frame_desc)434}435436/// Executes code creating a new stack frame, to be replaced with try{}437pub fn in_description_frame<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}445446#[derive(Trace)]447pub struct InitialUnderscore(pub Thunk<Val>);448impl ContextInitializer for InitialUnderscore {449	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {450		builder.bind("_", self.0.clone());451	}452453	fn as_any(&self) -> &dyn Any {454		self455	}456}457458/// Raw methods evaluate passed values but don't perform TLA execution459impl State {460	/// Parses and evaluates the given snippet461	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {462		let code = code.into();463		let source = Source::new_virtual(name.into(), code.clone());464		let parsed = jrsonnet_peg_parser::parse(465			&code,466			&ParserSettings {467				source: source.clone(),468			},469		)470		.map_err(|e| ImportSyntaxError {471			path: source.clone(),472			error: Box::new(e),473		})?;474		evaluate(self.create_default_context(source), &parsed)475	}476	/// Parses and evaluates the given snippet with custom context modifier477	pub fn evaluate_snippet_with(478		&self,479		name: impl Into<IStr>,480		code: impl Into<IStr>,481		context_initializer: impl ContextInitializer,482	) -> Result<Val> {483		let code = code.into();484		let source = Source::new_virtual(name.into(), code.clone());485		let parsed = jrsonnet_peg_parser::parse(486			&code,487			&ParserSettings {488				source: source.clone(),489			},490		)491		.map_err(|e| ImportSyntaxError {492			path: source.clone(),493			error: Box::new(e),494		})?;495		evaluate(496			self.create_default_context_with(source, context_initializer),497			&parsed,498		)499	}500}501502/// Settings utilities503impl State {504	// Only panics in case of [`ImportResolver`] contract violation505	#[allow(clippy::missing_panics_doc)]506	pub fn resolve_from(&self, from: &SourcePath, path: &dyn AsPathLike) -> Result<SourcePath> {507		self.import_resolver().resolve_from(from, path)508	}509	#[allow(clippy::missing_panics_doc)]510	pub fn resolve_from_default(&self, path: &dyn AsPathLike) -> Result<SourcePath> {511		self.import_resolver().resolve_from_default(path)512	}513	pub fn import_resolver(&self) -> &dyn ImportResolver {514		&*self.0.import_resolver515	}516	pub fn context_initializer(&self) -> &dyn ContextInitializer {517		&*self.0.context_initializer.0518	}519}520521impl State {522	pub fn builder() -> StateBuilder {523		StateBuilder::default()524	}525}526527impl Default for State {528	fn default() -> Self {529		Self::builder().build()530	}531}532533#[derive(Default)]534pub struct StateBuilder {535	import_resolver: Option<Rc<dyn ImportResolver>>,536	context_initializer: Option<CcContextInitializer>,537}538impl StateBuilder {539	pub fn import_resolver(&mut self, import_resolver: impl ImportResolver) -> &mut Self {540		let _ = self.import_resolver.insert(Rc::new(import_resolver));541		self542	}543	pub fn context_initializer(544		&mut self,545		context_initializer: impl ContextInitializer,546	) -> &mut Self {547		let _ = self548			.context_initializer549			.insert(CcContextInitializer::new(context_initializer));550		self551	}552	pub fn build(mut self) -> State {553		State(Cc::new(EvaluationStateInternals {554			file_cache: RefCell::new(FxHashMap::new()),555			context_initializer: self556				.context_initializer557				.take()558				.unwrap_or_else(|| CcContextInitializer::new(())),559			import_resolver: self560				.import_resolver561				.take()562				.unwrap_or_else(|| Rc::new(DummyImportResolver)),563		}))564	}565}