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

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,19	val::ThunkValue,20	MaybeUnbound, Result, State, Thunk, Unbound, Val,21};2223#[cfg(not(feature = "exp-preserve-order"))]24mod ordering {25	#![allow(26		// This module works as stub for preserve-order feature27		clippy::unused_self,28	)]2930	use jrsonnet_gcmodule::Trace;3132	#[derive(Clone, Copy, Default, Debug, Trace)]33	pub struct FieldIndex(());34	impl FieldIndex {35		pub const fn next(self) -> Self {36			Self(())37		}38	}3940	#[derive(Clone, Copy, Default, Debug, Trace)]41	pub struct SuperDepth(());42	impl SuperDepth {43		pub const fn deeper(self) -> Self {44			Self(())45		}46	}4748	#[derive(Clone, Copy)]49	pub struct FieldSortKey(());50	impl FieldSortKey {51		pub const fn new(_: SuperDepth, _: FieldIndex) -> Self {52			Self(())53		}54	}55}5657#[cfg(feature = "exp-preserve-order")]58mod ordering {59	use std::cmp::{Ordering, Reverse};6061	use jrsonnet_gcmodule::Trace;6263	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]64	pub struct FieldIndex(u32);65	impl FieldIndex {66		pub fn next(self) -> Self {67			Self(self.0 + 1)68		}69	}7071	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]72	pub struct SuperDepth(u32);73	impl SuperDepth {74		pub fn deeper(self) -> Self {75			Self(self.0 + 1)76		}77	}7879	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]80	pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);81	impl FieldSortKey {82		pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {83			Self(Reverse(depth), index)84		}85		pub fn collide(self, other: Self) -> Self {86			match self.0 .0.cmp(&other.0 .0) {87				Ordering::Greater => self,88				Ordering::Less => other,89				Ordering::Equal => unreachable!("object can't have two fields with the 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	pub fn builder() -> ObjValueBuilder {192		ObjValueBuilder::new()193	}194	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {195		ObjValueBuilder::with_capacity(capacity)196	}197	#[must_use]198	pub fn extend_from(&self, sup: Self) -> Self {199		match &self.0.sup {200			None => Self::new(201				Some(sup),202				self.0.this_entries.clone(),203				self.0.assertions.clone(),204			),205			Some(v) => Self::new(206				Some(v.extend_from(sup)),207				self.0.this_entries.clone(),208				self.0.assertions.clone(),209			),210		}211	}212	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {213		let mut new = GcHashMap::with_capacity(1);214		new.insert(key, value);215		Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))216	}217	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {218		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())219	}220221	#[must_use]222	pub fn with_this(&self, this: Self) -> Self {223		Self(Cc::new(ObjValueInternals {224			sup: self.0.sup.clone(),225			assertions: self.0.assertions.clone(),226			assertions_ran: RefCell::new(GcHashSet::new()),227			this: Some(this),228			this_entries: self.0.this_entries.clone(),229			value_cache: RefCell::new(GcHashMap::new()),230		}))231	}232233	pub fn len(&self) -> usize {234		self.fields_visibility()235			.into_iter()236			.filter(|(_, (visible, _))| *visible)237			.count()238	}239240	pub fn is_empty(&self) -> bool {241		if !self.0.this_entries.is_empty() {242			return false;243		}244		self.0.sup.as_ref().map_or(true, Self::is_empty)245	}246247	/// Run callback for every field found in object248	///249	/// Returns true if ended prematurely250	pub(crate) fn enum_fields(251		&self,252		depth: SuperDepth,253		handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,254	) -> bool {255		if let Some(s) = &self.0.sup {256			if s.enum_fields(depth.deeper(), handler) {257				return true;258			}259		}260		for (name, member) in self.0.this_entries.iter() {261			if handler(depth, name, member) {262				return true;263			}264		}265		false266	}267268	pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {269		let mut out = FxHashMap::default();270		self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {271			let new_sort_key = FieldSortKey::new(depth, member.original_index);272			let entry = out.entry(name.clone());273			let (visible, _) = entry.or_insert((true, new_sort_key));274			match member.visibility {275				Visibility::Normal => {}276				Visibility::Hidden => {277					*visible = false;278				}279				Visibility::Unhide => {280					*visible = true;281				}282			};283			false284		});285		out286	}287	pub fn fields_ex(288		&self,289		include_hidden: bool,290		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,291	) -> Vec<IStr> {292		#[cfg(feature = "exp-preserve-order")]293		if preserve_order {294			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self295				.fields_visibility()296				.into_iter()297				.filter(|(_, (visible, _))| include_hidden || *visible)298				.enumerate()299				.map(|(idx, (k, (_, sk)))| (k, (sk, idx)))300				.unzip();301			keys.sort_unstable_by_key(|v| v.0);302			// Reorder in-place by resulting indexes303			for i in 0..fields.len() {304				let x = fields[i].clone();305				let mut j = i;306				loop {307					let k = keys[j].1;308					keys[j].1 = j;309					if k == i {310						break;311					}312					fields[j] = fields[k].clone();313					j = k;314				}315				fields[j] = x;316			}317			return fields;318		}319320		let mut fields: Vec<_> = self321			.fields_visibility()322			.into_iter()323			.filter(|(_, (visible, _))| include_hidden || *visible)324			.map(|(k, _)| k)325			.collect();326		fields.sort_unstable();327		fields328	}329	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {330		self.fields_ex(331			false,332			#[cfg(feature = "exp-preserve-order")]333			preserve_order,334		)335	}336337	pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {338		if let Some(m) = self.0.this_entries.get(&name) {339			Some(match &m.visibility {340				Visibility::Normal => self341					.0342					.sup343					.as_ref()344					.and_then(|super_obj| super_obj.field_visibility(name))345					.unwrap_or(Visibility::Normal),346				v => *v,347			})348		} else if let Some(super_obj) = &self.0.sup {349			super_obj.field_visibility(name)350		} else {351			None352		}353	}354355	fn has_field_include_hidden(&self, name: IStr) -> bool {356		if self.0.this_entries.contains_key(&name) {357			true358		} else if let Some(super_obj) = &self.0.sup {359			super_obj.has_field_include_hidden(name)360		} else {361			false362		}363	}364365	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {366		if include_hidden {367			self.has_field_include_hidden(name)368		} else {369			self.has_field(name)370		}371	}372	pub fn has_field(&self, name: IStr) -> bool {373		self.field_visibility(name)374			.map_or(false, |v| v.is_visible())375	}376377	pub fn iter(378		&self,379		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,380	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {381		let fields = self.fields(382			#[cfg(feature = "exp-preserve-order")]383			preserve_order,384		);385		fields.into_iter().map(|field| {386			(387				field.clone(),388				self.get(field)389					.map(|opt| opt.expect("iterating over keys, field exists")),390			)391		})392	}393394	pub fn get(&self, key: IStr) -> Result<Option<Val>> {395		self.run_assertions()?;396		let cache_key = (key.clone(), None);397		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {398			return Ok(match v {399				CacheValue::Cached(v) => Some(v.clone()),400				CacheValue::NotFound => None,401				CacheValue::Pending => throw!(InfiniteRecursionDetected),402				CacheValue::Errored(e) => return Err(e.clone()),403			});404		}405		self.0406			.value_cache407			.borrow_mut()408			.insert(cache_key.clone(), CacheValue::Pending);409		let value = self410			.get_raw(key, self.0.this.clone().unwrap_or_else(|| self.clone()))411			.map_err(|e| {412				self.0413					.value_cache414					.borrow_mut()415					.insert(cache_key.clone(), CacheValue::Errored(e.clone()));416				e417			})?;418		self.0.value_cache.borrow_mut().insert(419			cache_key,420			value421				.as_ref()422				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),423		);424		Ok(value)425	}426	pub fn get_for(&self, key: IStr, this: Self) -> Result<Option<Val>> {427		self.run_assertions()?;428		let cache_key = (key.clone(), Some(this.clone().downgrade()));429		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {430			return Ok(match v {431				CacheValue::Cached(v) => Some(v.clone()),432				CacheValue::NotFound => None,433				CacheValue::Pending => throw!(InfiniteRecursionDetected),434				CacheValue::Errored(e) => return Err(e.clone()),435			});436		}437		self.0438			.value_cache439			.borrow_mut()440			.insert(cache_key.clone(), CacheValue::Pending);441		let value = self.get_raw(key, this).map_err(|e| {442			self.0443				.value_cache444				.borrow_mut()445				.insert(cache_key.clone(), CacheValue::Errored(e.clone()));446			e447		})?;448		self.0.value_cache.borrow_mut().insert(449			cache_key,450			value451				.as_ref()452				.map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),453		);454		Ok(value)455	}456457	fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {458		match (self.0.this_entries.get(&key), &self.0.sup) {459			(Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),460			(Some(k), Some(super_obj)) => {461				let our = self.evaluate_this(k, real_this.clone())?;462				if k.add {463					super_obj464						.get_raw(key, real_this)?465						.map_or(Ok(Some(our.clone())), |v| {466							Ok(Some(evaluate_add_op(&v, &our)?))467						})468				} else {469					Ok(Some(our))470				}471			}472			(None, Some(super_obj)) => super_obj.get_raw(key, real_this),473			(None, None) => Ok(None),474		}475	}476	fn evaluate_this(&self, v: &ObjMember, real_this: Self) -> Result<Val> {477		v.invoke.evaluate(self.0.sup.clone(), Some(real_this))478	}479480	fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {481		if self.0.assertions.is_empty() {482			if let Some(super_obj) = &self.0.sup {483				super_obj.run_assertions_raw(real_this)?;484			}485			return Ok(());486		}487		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {488			for assertion in self.0.assertions.iter() {489				if let Err(e) = assertion.run(self.0.sup.clone(), Some(real_this.clone())) {490					self.0.assertions_ran.borrow_mut().remove(real_this);491					return Err(e);492				}493			}494			if let Some(super_obj) = &self.0.sup {495				super_obj.run_assertions_raw(real_this)?;496			}497		}498		Ok(())499	}500	pub fn run_assertions(&self) -> Result<()> {501		self.run_assertions_raw(self)502	}503504	pub fn ptr_eq(a: &Self, b: &Self) -> bool {505		Cc::ptr_eq(&a.0, &b.0)506	}507	pub fn downgrade(self) -> WeakObjValue {508		WeakObjValue(self.0.downgrade())509	}510}511512impl PartialEq for ObjValue {513	fn eq(&self, other: &Self) -> bool {514		Cc::ptr_eq(&self.0, &other.0)515	}516}517518impl Eq for ObjValue {}519impl Hash for ObjValue {520	fn hash<H: Hasher>(&self, hasher: &mut H) {521		hasher.write_usize(addr_of!(*self.0) as usize);522	}523}524525#[allow(clippy::module_name_repetitions)]526pub struct ObjValueBuilder {527	sup: Option<ObjValue>,528	map: GcHashMap<IStr, ObjMember>,529	assertions: Vec<TraceBox<dyn ObjectAssertion>>,530	next_field_index: FieldIndex,531}532impl ObjValueBuilder {533	pub fn new() -> Self {534		Self::with_capacity(0)535	}536	pub fn with_capacity(capacity: usize) -> Self {537		Self {538			sup: None,539			map: GcHashMap::with_capacity(capacity),540			assertions: Vec::new(),541			next_field_index: FieldIndex::default(),542		}543	}544	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {545		self.assertions.reserve_exact(capacity);546		self547	}548	pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {549		self.sup = Some(super_obj);550		self551	}552553	pub fn assert(&mut self, assertion: impl ObjectAssertion + 'static) -> &mut Self {554		self.assertions.push(tb!(assertion));555		self556	}557	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {558		let field_index = self.next_field_index;559		self.next_field_index = self.next_field_index.next();560		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)561	}562563	pub fn build(self) -> ObjValue {564		ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))565	}566}567impl Default for ObjValueBuilder {568	fn default() -> Self {569		Self::with_capacity(0)570	}571}572573#[allow(clippy::module_name_repetitions)]574#[must_use = "value not added unless binding() was called"]575pub struct ObjMemberBuilder<Kind> {576	kind: Kind,577	name: IStr,578	add: bool,579	visibility: Visibility,580	original_index: FieldIndex,581	location: Option<ExprLocation>,582}583584#[allow(clippy::missing_const_for_fn)]585impl<Kind> ObjMemberBuilder<Kind> {586	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {587		Self {588			kind,589			name,590			original_index,591			add: false,592			visibility: Visibility::Normal,593			location: None,594		}595	}596597	pub const fn with_add(mut self, add: bool) -> Self {598		self.add = add;599		self600	}601	pub fn add(self) -> Self {602		self.with_add(true)603	}604	pub fn with_visibility(mut self, visibility: Visibility) -> Self {605		self.visibility = visibility;606		self607	}608	pub fn hide(self) -> Self {609		self.with_visibility(Visibility::Hidden)610	}611	pub fn with_location(mut self, location: ExprLocation) -> Self {612		self.location = Some(location);613		self614	}615	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {616		(617			self.kind,618			self.name,619			ObjMember {620				add: self.add,621				visibility: self.visibility,622				original_index: self.original_index,623				invoke: binding,624				location: self.location,625			},626		)627	}628}629630pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);631impl ObjMemberBuilder<ValueBuilder<'_>> {632	/// Inserts value, replacing if it is already defined633	pub fn value_unchecked(self, value: Val) {634		let (receiver, name, member) =635			self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value)));636		let entry = receiver.0.map.entry(name);637		entry.insert(member);638	}639640	pub fn value(self, value: Val) -> Result<()> {641		self.thunk(Thunk::evaluated(value))642	}643	pub fn thunk(self, value: Thunk<Val>) -> Result<()> {644		self.binding(MaybeUnbound::Bound(value))645	}646	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) -> Result<()> {647		self.binding(MaybeUnbound::Unbound(Cc::new(tb!(bindable))))648	}649	pub fn binding(self, binding: MaybeUnbound) -> Result<()> {650		let (receiver, name, member) = self.build_member(binding);651		let location = member.location.clone();652		let old = receiver.0.map.insert(name.clone(), member);653		if old.is_some() {654			State::push(655				CallLocation(location.as_ref()),656				|| format!("field <{}> initializtion", name.clone()),657				|| throw!(DuplicateFieldName(name.clone())),658			)?;659		}660		Ok(())661	}662}663664pub struct ExtendBuilder<'v>(&'v mut ObjValue);665impl ObjMemberBuilder<ExtendBuilder<'_>> {666	pub fn value(self, value: Val) {667		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));668	}669	pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Val>>) {670		self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));671	}672	pub fn binding(self, binding: MaybeUnbound) {673		let (receiver, name, member) = self.build_member(binding);674		let new = receiver.0.clone();675		*receiver.0 = new.extend_with_raw_member(name, member);676	}677}