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

1use std::{2	cell::RefCell,3	fmt::Debug,4	hash::{Hash, Hasher},5	ptr::addr_of,6};78use jrsonnet_gcmodule::{Cc, Trace, Weak};9use jrsonnet_interner::IStr;10use jrsonnet_parser::{ExprLocation, Visibility};11use rustc_hash::FxHashMap;1213use crate::{14	error::{Error, ErrorKind::*},15	function::CallLocation,16	gc::{GcHashMap, GcHashSet, TraceBox},17	operator::evaluate_add_op,18	tb, throw, MaybeUnbound, Result, State, Thunk, Unbound, Val,19};2021#[cfg(not(feature = "exp-preserve-order"))]22mod ordering {23	#![allow(24		// This module works as stub for preserve-order feature25		clippy::unused_self,26	)]2728	use jrsonnet_gcmodule::Trace;2930	#[derive(Clone, Copy, Default, Debug, Trace)]31	pub struct FieldIndex;32	impl FieldIndex {33		pub const fn next(self) -> Self {34			Self35		}36	}3738	#[derive(Clone, Copy, Default, Debug, Trace)]39	pub struct SuperDepth;40	impl SuperDepth {41		pub const fn deeper(self) -> Self {42			Self43		}44	}4546	#[derive(Clone, Copy)]47	pub struct FieldSortKey;48	impl FieldSortKey {49		pub const fn new(_: SuperDepth, _: FieldIndex) -> Self {50			Self51		}52	}53}5455#[cfg(feature = "exp-preserve-order")]56mod ordering {57	use std::cmp::Reverse;5859	use jrsonnet_gcmodule::Trace;6061	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]62	pub struct FieldIndex(u32);63	impl FieldIndex {64		pub fn next(self) -> Self {65			Self(self.0 + 1)66		}67	}6869	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]70	pub struct SuperDepth(u32);71	impl SuperDepth {72		pub fn deeper(self) -> Self {73			Self(self.0 + 1)74		}75	}7677	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]78	pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);79	impl FieldSortKey {80		pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {81			Self(Reverse(depth), index)82		}83		pub fn collide(self, other: Self) -> Self {84			if self.0 .0 > other.0 .0 {85				self86			} else if self.0 .0 < other.0 .0 {87				other88			} else {89				unreachable!("object can't have two fields with same name")90			}91		}92	}93}9495use ordering::*;9697#[allow(clippy::module_name_repetitions)]98#[derive(Debug, Trace)]99pub struct ObjMember {100	pub add: bool,101	pub visibility: Visibility,102	original_index: FieldIndex,103	pub invoke: MaybeUnbound,104	pub location: Option<ExprLocation>,105}106107pub trait ObjectAssertion: Trace {108	fn run(&self, super_obj: Option<ObjValue>, this: Option<ObjValue>) -> Result<()>;109}110111// Field => This112113#[derive(Trace)]114enum CacheValue {115	Cached(Val),116	NotFound,117	Pending,118	Errored(Error),119}120121#[allow(clippy::module_name_repetitions)]122#[derive(Trace)]123#[trace(tracking(force))]124pub struct ObjValueInternals {125	sup: Option<ObjValue>,126	this: Option<ObjValue>,127128	assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,129	assertions_ran: RefCell<GcHashSet<ObjValue>>,130	this_entries: Cc<GcHashMap<IStr, ObjMember>>,131	value_cache: RefCell<GcHashMap<(IStr, Option<WeakObjValue>), CacheValue>>,132}133134#[derive(Clone, Trace)]135pub struct WeakObjValue(#[trace(skip)] pub(crate) Weak<ObjValueInternals>);136137impl PartialEq for WeakObjValue {138	fn eq(&self, other: &Self) -> bool {139		Weak::ptr_eq(&self.0, &other.0)140	}141}142143impl Eq for WeakObjValue {}144impl Hash for WeakObjValue {145	fn hash<H: Hasher>(&self, hasher: &mut H) {146		// Safety: usize is POD147		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };148		hasher.write_usize(addr);149	}150}151152#[allow(clippy::module_name_repetitions)]153#[derive(Clone, Trace)]154pub struct ObjValue(pub(crate) Cc<ObjValueInternals>);155impl Debug for ObjValue {156	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {157		if let Some(super_obj) = self.0.sup.as_ref() {158			if f.alternate() {159				write!(f, "{super_obj:#?}")?;160			} else {161				write!(f, "{super_obj:?}")?;162			}163			write!(f, " + ")?;164		}165		let mut debug = f.debug_struct("ObjValue");166		for (name, member) in self.0.this_entries.iter() {167			debug.field(name, member);168		}169		debug.finish_non_exhaustive()170	}171}172173impl ObjValue {174	pub fn new(175		sup: Option<Self>,176		this_entries: Cc<GcHashMap<IStr, ObjMember>>,177		assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,178	) -> Self {179		Self(Cc::new(ObjValueInternals {180			sup,181			this: None,182			assertions,183			assertions_ran: RefCell::new(GcHashSet::new()),184			this_entries,185			value_cache: RefCell::new(GcHashMap::new()),186		}))187	}188	pub fn new_empty() -> Self {189		Self::new(None, Cc::new(GcHashMap::new()), Cc::new(Vec::new()))190	}191	#[must_use]192	pub fn extend_from(&self, sup: Self) -> Self {193		match &self.0.sup {194			None => Self::new(195				Some(sup),196				self.0.this_entries.clone(),197				self.0.assertions.clone(),198			),199			Some(v) => Self::new(200				Some(v.extend_from(sup)),201				self.0.this_entries.clone(),202				self.0.assertions.clone(),203			),204		}205	}206	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {207		let mut new = GcHashMap::with_capacity(1);208		new.insert(key, value);209		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))210	}211	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {212		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())213	}214215	#[must_use]216	pub fn with_this(&self, this: Self) -> Self {217		Self(Cc::new(ObjValueInternals {218			sup: self.0.sup.clone(),219			assertions: self.0.assertions.clone(),220			assertions_ran: RefCell::new(GcHashSet::new()),221			this: Some(this),222			this_entries: self.0.this_entries.clone(),223			value_cache: RefCell::new(GcHashMap::new()),224		}))225	}226227	pub fn len(&self) -> usize {228		self.fields_visibility()229			.into_iter()230			.filter(|(_, (visible, _))| *visible)231			.count()232	}233234	pub fn is_empty(&self) -> bool {235		if !self.0.this_entries.is_empty() {236			return false;237		}238		self.0.sup.as_ref().map_or(true, Self::is_empty)239	}240241	/// Run callback for every field found in object242	///243	/// Returns true if ended prematurely244	pub(crate) fn enum_fields(245		&self,246		depth: SuperDepth,247		handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,248	) -> bool {249		if let Some(s) = &self.0.sup {250			if s.enum_fields(depth.deeper(), handler) {251				return true;252			}253		}254		for (name, member) in self.0.this_entries.iter() {255			if handler(depth, name, member) {256				return true;257			}258		}259		false260	}261262	pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {263		let mut out = FxHashMap::default();264		self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {265			let new_sort_key = FieldSortKey::new(depth, member.original_index);266			let entry = out.entry(name.clone());267			let (visible, _) = entry.or_insert((true, new_sort_key));268			match member.visibility {269				Visibility::Normal => {}270				Visibility::Hidden => {271					*visible = false;272				}273				Visibility::Unhide => {274					*visible = true;275				}276			};277			false278		});279		out280	}281	pub fn fields_ex(282		&self,283		include_hidden: bool,284		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,285	) -> Vec<IStr> {286		#[cfg(feature = "exp-preserve-order")]287		if preserve_order {288			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self289				.fields_visibility()290				.into_iter()291				.filter(|(_, (visible, _))| include_hidden || *visible)292				.enumerate()293				.map(|(idx, (k, (_, sk)))| (k, (sk, idx)))294				.unzip();295			keys.sort_unstable_by_key(|v| v.0);296			// Reorder in-place by resulting indexes297			for i in 0..fields.len() {298				let x = fields[i].clone();299				let mut j = i;300				loop {301					let k = keys[j].1;302					keys[j].1 = j;303					if k == i {304						break;305					}306					fields[j] = fields[k].clone();307					j = k308				}309				fields[j] = x;310			}311			return fields;312		}313314		let mut fields: Vec<_> = self315			.fields_visibility()316			.into_iter()317			.filter(|(_, (visible, _))| include_hidden || *visible)318			.map(|(k, _)| k)319			.collect();320		fields.sort_unstable();321		fields322	}323	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {324		self.fields_ex(325			false,326			#[cfg(feature = "exp-preserve-order")]327			preserve_order,328		)329	}330331	pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {332		if let Some(m) = self.0.this_entries.get(&name) {333			Some(match &m.visibility {334				Visibility::Normal => self335					.0336					.sup337					.as_ref()338					.and_then(|super_obj| super_obj.field_visibility(name))339					.unwrap_or(Visibility::Normal),340				v => *v,341			})342		} else if let Some(super_obj) = &self.0.sup {343			super_obj.field_visibility(name)344		} else {345			None346		}347	}348349	fn has_field_include_hidden(&self, name: IStr) -> bool {350		if self.0.this_entries.contains_key(&name) {351			true352		} else if let Some(super_obj) = &self.0.sup {353			super_obj.has_field_include_hidden(name)354		} else {355			false356		}357	}358359	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {360		if include_hidden {361			self.has_field_include_hidden(name)362		} else {363			self.has_field(name)364		}365	}366	pub fn has_field(&self, name: IStr) -> bool {367		self.field_visibility(name)368			.map_or(false, |v| v.is_visible())369	}370371	pub fn iter(372		&self,373		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,374	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {375		let fields = self.fields(376			#[cfg(feature = "exp-preserve-order")]377			preserve_order,378		);379		fields.into_iter().map(|field| {380			(381				field.clone(),382				self.get(field)383					.map(|opt| opt.expect("iterating over keys, field exists")),384			)385		})386	}387388	pub fn get(&self, key: IStr) -> Result<Option<Val>> {389		self.run_assertions()?;390		let cache_key = (key.clone(), None);391		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {392			return Ok(match v {393				CacheValue::Cached(v) => Some(v.clone()),394				CacheValue::NotFound => None,395				CacheValue::Pending => throw!(InfiniteRecursionDetected),396				CacheValue::Errored(e) => return Err(e.clone()),397			});398		}399		self.0400			.value_cache401			.borrow_mut()402			.insert(cache_key.clone(), CacheValue::Pending);403		let value = self404			.get_raw(key, self.0.this.clone().unwrap_or_else(|| self.clone()))405			.map_err(|e| {406				self.0407					.value_cache408					.borrow_mut()409					.insert(cache_key.clone(), CacheValue::Errored(e.clone()));410				e411			})?;412		self.0.value_cache.borrow_mut().insert(413			cache_key,414			value415				.as_ref()416				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),417		);418		Ok(value)419	}420	pub fn get_for(&self, key: IStr, this: Self) -> Result<Option<Val>> {421		self.run_assertions()?;422		let cache_key = (key.clone(), Some(this.clone().downgrade()));423		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {424			return Ok(match v {425				CacheValue::Cached(v) => Some(v.clone()),426				CacheValue::NotFound => None,427				CacheValue::Pending => throw!(InfiniteRecursionDetected),428				CacheValue::Errored(e) => return Err(e.clone()),429			});430		}431		self.0432			.value_cache433			.borrow_mut()434			.insert(cache_key.clone(), CacheValue::Pending);435		let value = self.get_raw(key, this).map_err(|e| {436			self.0437				.value_cache438				.borrow_mut()439				.insert(cache_key.clone(), CacheValue::Errored(e.clone()));440			e441		})?;442		self.0.value_cache.borrow_mut().insert(443			cache_key,444			value445				.as_ref()446				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),447		);448		Ok(value)449	}450451	fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {452		match (self.0.this_entries.get(&key), &self.0.sup) {453			(Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),454			(Some(k), Some(super_obj)) => {455				let our = self.evaluate_this(k, real_this.clone())?;456				if k.add {457					super_obj458						.get_raw(key, real_this)?459						.map_or(Ok(Some(our.clone())), |v| {460							Ok(Some(evaluate_add_op(&v, &our)?))461						})462				} else {463					Ok(Some(our))464				}465			}466			(None, Some(super_obj)) => super_obj.get_raw(key, real_this),467			(None, None) => Ok(None),468		}469	}470	fn evaluate_this(&self, v: &ObjMember, real_this: Self) -> Result<Val> {471		v.invoke.evaluate(self.0.sup.clone(), Some(real_this))472	}473474	fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {475		if self.0.assertions.is_empty() {476			if let Some(super_obj) = &self.0.sup {477				super_obj.run_assertions_raw(real_this)?;478			}479			return Ok(());480		}481		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {482			for assertion in self.0.assertions.iter() {483				if let Err(e) = assertion.run(self.0.sup.clone(), Some(real_this.clone())) {484					self.0.assertions_ran.borrow_mut().remove(real_this);485					return Err(e);486				}487			}488			if let Some(super_obj) = &self.0.sup {489				super_obj.run_assertions_raw(real_this)?;490			}491		}492		Ok(())493	}494	pub fn run_assertions(&self) -> Result<()> {495		self.run_assertions_raw(self)496	}497498	pub fn ptr_eq(a: &Self, b: &Self) -> bool {499		Cc::ptr_eq(&a.0, &b.0)500	}501	pub fn downgrade(self) -> WeakObjValue {502		WeakObjValue(self.0.downgrade())503	}504}505506impl PartialEq for ObjValue {507	fn eq(&self, other: &Self) -> bool {508		Cc::ptr_eq(&self.0, &other.0)509	}510}511512impl Eq for ObjValue {}513impl Hash for ObjValue {514	fn hash<H: Hasher>(&self, hasher: &mut H) {515		hasher.write_usize(addr_of!(*self.0) as usize);516	}517}518519#[allow(clippy::module_name_repetitions)]520pub struct ObjValueBuilder {521	sup: Option<ObjValue>,522	map: GcHashMap<IStr, ObjMember>,523	assertions: Vec<TraceBox<dyn ObjectAssertion>>,524	next_field_index: FieldIndex,525}526impl ObjValueBuilder {527	pub fn new() -> Self {528		Self::with_capacity(0)529	}530	pub fn with_capacity(capacity: usize) -> Self {531		Self {532			sup: None,533			map: GcHashMap::with_capacity(capacity),534			assertions: Vec::new(),535			next_field_index: FieldIndex::default(),536		}537	}538	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {539		self.assertions.reserve_exact(capacity);540		self541	}542	pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {543		self.sup = Some(super_obj);544		self545	}546547	pub fn assert(&mut self, assertion: impl ObjectAssertion + 'static) -> &mut Self {548		self.assertions.push(tb!(assertion));549		self550	}551	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {552		let field_index = self.next_field_index;553		self.next_field_index = self.next_field_index.next();554		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)555	}556557	pub fn build(self) -> ObjValue {558		ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))559	}560}561impl Default for ObjValueBuilder {562	fn default() -> Self {563		Self::with_capacity(0)564	}565}566567#[allow(clippy::module_name_repetitions)]568#[must_use = "value not added unless binding() was called"]569pub struct ObjMemberBuilder<Kind> {570	kind: Kind,571	name: IStr,572	add: bool,573	visibility: Visibility,574	original_index: FieldIndex,575	location: Option<ExprLocation>,576}577578#[allow(clippy::missing_const_for_fn)]579impl<Kind> ObjMemberBuilder<Kind> {580	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {581		Self {582			kind,583			name,584			original_index,585			add: false,586			visibility: Visibility::Normal,587			location: None,588		}589	}590591	pub const fn with_add(mut self, add: bool) -> Self {592		self.add = add;593		self594	}595	pub fn add(self) -> Self {596		self.with_add(true)597	}598	pub fn with_visibility(mut self, visibility: Visibility) -> Self {599		self.visibility = visibility;600		self601	}602	pub fn hide(self) -> Self {603		self.with_visibility(Visibility::Hidden)604	}605	pub fn with_location(mut self, location: ExprLocation) -> Self {606		self.location = Some(location);607		self608	}609	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {610		(611			self.kind,612			self.name,613			ObjMember {614				add: self.add,615				visibility: self.visibility,616				original_index: self.original_index,617				invoke: binding,618				location: self.location,619			},620		)621	}622}623624pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);625impl ObjMemberBuilder<ValueBuilder<'_>> {626	/// Inserts value, replacing if it is already defined627	pub fn value_unchecked(self, value: Val) {628		let (receiver, name, member) =629			self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value)));630		let entry = receiver.0.map.entry(name);631		entry.insert(member);632	}633634	pub fn value(self, value: Val) -> Result<()> {635		self.thunk(Thunk::evaluated(value))636	}637	pub fn thunk(self, value: Thunk<Val>) -> Result<()> {638		self.binding(MaybeUnbound::Bound(value))639	}640	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) -> Result<()> {641		self.binding(MaybeUnbound::Unbound(Cc::new(tb!(bindable))))642	}643	pub fn binding(self, binding: MaybeUnbound) -> Result<()> {644		let (receiver, name, member) = self.build_member(binding);645		let location = member.location.clone();646		let old = receiver.0.map.insert(name.clone(), member);647		if old.is_some() {648			State::push(649				CallLocation(location.as_ref()),650				|| format!("field <{}> initializtion", name.clone()),651				|| throw!(DuplicateFieldName(name.clone())),652			)?;653		}654		Ok(())655	}656}657658pub struct ExtendBuilder<'v>(&'v mut ObjValue);659impl ObjMemberBuilder<ExtendBuilder<'_>> {660	pub fn value(self, value: Val) {661		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));662	}663	pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Val>>) {664		self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));665	}666	pub fn binding(self, binding: MaybeUnbound) {667		let (receiver, name, member) = self.build_member(binding);668		let new = receiver.0.clone();669		*receiver.0 = new.extend_with_raw_member(name, member);670	}671}