git.delta.rocks / jrsonnet / refs/commits / 70f37833046b

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::*, LocError},15	function::CallLocation,16	gc::{GcHashMap, GcHashSet, TraceBox},17	operator::evaluate_add_op,18	throw, LazyBinding, 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: LazyBinding,104	pub location: Option<ExprLocation>,105}106107pub trait ObjectAssertion: Trace {108	fn run(&self, s: State, 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(LocError),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, 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	pub(crate) fn enum_fields(243		&self,244		depth: SuperDepth,245		handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,246	) -> bool {247		if let Some(s) = &self.0.sup {248			if s.enum_fields(depth.deeper(), handler) {249				return true;250			}251		}252		for (name, member) in self.0.this_entries.iter() {253			if handler(depth, name, member) {254				return true;255			}256		}257		false258	}259260	pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {261		let mut out = FxHashMap::default();262		self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {263			let new_sort_key = FieldSortKey::new(depth, member.original_index);264			let entry = out.entry(name.clone());265			let (visible, _) = entry.or_insert((true, new_sort_key));266			match member.visibility {267				Visibility::Normal => {}268				Visibility::Hidden => {269					*visible = false;270				}271				Visibility::Unhide => {272					*visible = true;273				}274			};275			false276		});277		out278	}279	pub fn fields_ex(280		&self,281		include_hidden: bool,282		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,283	) -> Vec<IStr> {284		#[cfg(feature = "exp-preserve-order")]285		if preserve_order {286			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self287				.fields_visibility()288				.into_iter()289				.filter(|(_, (visible, _))| include_hidden || *visible)290				.enumerate()291				.map(|(idx, (k, (_, sk)))| (k, (sk, idx)))292				.unzip();293			keys.sort_unstable_by_key(|v| v.0);294			// Reorder in-place by resulting indexes295			for i in 0..fields.len() {296				let x = fields[i].clone();297				let mut j = i;298				loop {299					let k = keys[j].1;300					keys[j].1 = j;301					if k == i {302						break;303					}304					fields[j] = fields[k].clone();305					j = k306				}307				fields[j] = x;308			}309			return fields;310		}311312		let mut fields: Vec<_> = self313			.fields_visibility()314			.into_iter()315			.filter(|(_, (visible, _))| include_hidden || *visible)316			.map(|(k, _)| k)317			.collect();318		fields.sort_unstable();319		fields320	}321	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {322		self.fields_ex(323			false,324			#[cfg(feature = "exp-preserve-order")]325			preserve_order,326		)327	}328329	pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {330		if let Some(m) = self.0.this_entries.get(&name) {331			Some(match &m.visibility {332				Visibility::Normal => self333					.0334					.sup335					.as_ref()336					.and_then(|super_obj| super_obj.field_visibility(name))337					.unwrap_or(Visibility::Normal),338				v => *v,339			})340		} else if let Some(super_obj) = &self.0.sup {341			super_obj.field_visibility(name)342		} else {343			None344		}345	}346347	fn has_field_include_hidden(&self, name: IStr) -> bool {348		if self.0.this_entries.contains_key(&name) {349			true350		} else if let Some(super_obj) = &self.0.sup {351			super_obj.has_field_include_hidden(name)352		} else {353			false354		}355	}356357	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {358		if include_hidden {359			self.has_field_include_hidden(name)360		} else {361			self.has_field(name)362		}363	}364	pub fn has_field(&self, name: IStr) -> bool {365		self.field_visibility(name)366			.map_or(false, |v| v.is_visible())367	}368369	pub fn get(&self, s: State, key: IStr) -> Result<Option<Val>> {370		self.run_assertions(s.clone())?;371		if let Some(v) = self.0.value_cache.borrow().get(&key) {372			return Ok(match v {373				CacheValue::Cached(v) => Some(v.clone()),374				CacheValue::NotFound => None,375				CacheValue::Pending => throw!(InfiniteRecursionDetected),376				CacheValue::Errored(e) => return Err(e.clone()),377			});378		}379		self.0380			.value_cache381			.borrow_mut()382			.insert(key.clone(), CacheValue::Pending);383		let value = self384			.get_raw(385				s,386				key.clone(),387				self.0.this.clone().unwrap_or_else(|| self.clone()),388			)389			.map_err(|e| {390				self.0391					.value_cache392					.borrow_mut()393					.insert(key.clone(), CacheValue::Errored(e.clone()));394				e395			})?;396		self.0.value_cache.borrow_mut().insert(397			key,398			match &value {399				Some(v) => CacheValue::Cached(v.clone()),400				None => CacheValue::NotFound,401			},402		);403		Ok(value)404	}405406	fn get_raw(&self, s: State, key: IStr, real_this: Self) -> Result<Option<Val>> {407		match (self.0.this_entries.get(&key), &self.0.sup) {408			(Some(k), None) => Ok(Some(self.evaluate_this(s, k, real_this)?)),409			(Some(k), Some(super_obj)) => {410				let our = self.evaluate_this(s.clone(), k, real_this.clone())?;411				if k.add {412					super_obj413						.get_raw(s.clone(), key, real_this)?414						.map_or(Ok(Some(our.clone())), |v| {415							Ok(Some(evaluate_add_op(s.clone(), &v, &our)?))416						})417				} else {418					Ok(Some(our))419				}420			}421			(None, Some(super_obj)) => super_obj.get_raw(s, key, real_this),422			(None, None) => Ok(None),423		}424	}425	fn evaluate_this(&self, s: State, v: &ObjMember, real_this: Self) -> Result<Val> {426		v.invoke427			.evaluate(s.clone(), self.0.sup.clone(), Some(real_this))?428			.evaluate(s)429	}430431	fn run_assertions_raw(&self, s: State, real_this: &Self) -> Result<()> {432		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {433			for assertion in self.0.assertions.iter() {434				if let Err(e) =435					assertion.run(s.clone(), self.0.sup.clone(), Some(real_this.clone()))436				{437					self.0.assertions_ran.borrow_mut().remove(real_this);438					return Err(e);439				}440			}441			if let Some(super_obj) = &self.0.sup {442				super_obj.run_assertions_raw(s, real_this)?;443			}444		}445		Ok(())446	}447	pub fn run_assertions(&self, s: State) -> Result<()> {448		self.run_assertions_raw(s, self)449	}450451	pub fn ptr_eq(a: &Self, b: &Self) -> bool {452		Cc::ptr_eq(&a.0, &b.0)453	}454	pub fn downgrade(self) -> WeakObjValue {455		WeakObjValue(self.0.downgrade())456	}457}458459impl PartialEq for ObjValue {460	fn eq(&self, other: &Self) -> bool {461		Cc::ptr_eq(&self.0, &other.0)462	}463}464465impl Eq for ObjValue {}466impl Hash for ObjValue {467	fn hash<H: Hasher>(&self, hasher: &mut H) {468		hasher.write_usize(addr_of!(*self.0) as usize);469	}470}471472#[allow(clippy::module_name_repetitions)]473pub struct ObjValueBuilder {474	sup: Option<ObjValue>,475	map: GcHashMap<IStr, ObjMember>,476	assertions: Vec<TraceBox<dyn ObjectAssertion>>,477	next_field_index: FieldIndex,478}479impl ObjValueBuilder {480	pub fn new() -> Self {481		Self::with_capacity(0)482	}483	pub fn with_capacity(capacity: usize) -> Self {484		Self {485			sup: None,486			map: GcHashMap::with_capacity(capacity),487			assertions: Vec::new(),488			next_field_index: FieldIndex::default(),489		}490	}491	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {492		self.assertions.reserve_exact(capacity);493		self494	}495	pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {496		self.sup = Some(super_obj);497		self498	}499500	pub fn assert(&mut self, assertion: TraceBox<dyn ObjectAssertion>) -> &mut Self {501		self.assertions.push(assertion);502		self503	}504	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder> {505		let field_index = self.next_field_index;506		self.next_field_index = self.next_field_index.next();507		ObjMemberBuilder::new(ValueBuilder(self), name, field_index)508	}509510	pub fn build(self) -> ObjValue {511		ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))512	}513}514impl Default for ObjValueBuilder {515	fn default() -> Self {516		Self::with_capacity(0)517	}518}519520#[allow(clippy::module_name_repetitions)]521#[must_use = "value not added unless binding() was called"]522pub struct ObjMemberBuilder<Kind> {523	kind: Kind,524	name: IStr,525	add: bool,526	visibility: Visibility,527	original_index: FieldIndex,528	location: Option<ExprLocation>,529}530531#[allow(clippy::missing_const_for_fn)]532impl<Kind> ObjMemberBuilder<Kind> {533	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {534		Self {535			kind,536			name,537			original_index,538			add: false,539			visibility: Visibility::Normal,540			location: None,541		}542	}543544	pub const fn with_add(mut self, add: bool) -> Self {545		self.add = add;546		self547	}548	pub fn add(self) -> Self {549		self.with_add(true)550	}551	pub fn with_visibility(mut self, visibility: Visibility) -> Self {552		self.visibility = visibility;553		self554	}555	pub fn hide(self) -> Self {556		self.with_visibility(Visibility::Hidden)557	}558	pub fn with_location(mut self, location: ExprLocation) -> Self {559		self.location = Some(location);560		self561	}562	fn build_member(self, binding: LazyBinding) -> (Kind, IStr, ObjMember) {563		(564			self.kind,565			self.name,566			ObjMember {567				add: self.add,568				visibility: self.visibility,569				original_index: self.original_index,570				invoke: binding,571				location: self.location,572			},573		)574	}575}576577pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);578impl<'v> ObjMemberBuilder<ValueBuilder<'v>> {579	pub fn value(self, s: State, value: Val) -> Result<()> {580		self.binding(s, LazyBinding::Bound(Thunk::evaluated(value)))581	}582	pub fn bindable(583		self,584		s: State,585		bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>,586	) -> Result<()> {587		self.binding(s, LazyBinding::Bindable(Cc::new(bindable)))588	}589	pub fn binding(self, s: State, binding: LazyBinding) -> Result<()> {590		let (receiver, name, member) = self.build_member(binding);591		let location = member.location.clone();592		let old = receiver.0.map.insert(name.clone(), member);593		if old.is_some() {594			s.push(595				CallLocation(location.as_ref()),596				|| format!("field <{}> initializtion", name.clone()),597				|| throw!(DuplicateFieldName(name.clone())),598			)?;599		}600		Ok(())601	}602}603604pub struct ExtendBuilder<'v>(&'v mut ObjValue);605impl<'v> ObjMemberBuilder<ExtendBuilder<'v>> {606	pub fn value(self, value: Val) {607		self.binding(LazyBinding::Bound(Thunk::evaluated(value)));608	}609	pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>) {610		self.binding(LazyBinding::Bindable(Cc::new(bindable)));611	}612	pub fn binding(self, binding: LazyBinding) {613		let (receiver, name, member) = self.build_member(binding);614		let new = receiver.0.clone();615		*receiver.0 = new.extend_with_raw_member(name, member);616	}617}