git.delta.rocks / jrsonnet / refs/commits / 6d535da7fe1f

1use crate::operator::evaluate_add_op;2use crate::{Bindable, LazyBinding, LazyVal, Result, Val};3use jrsonnet_gc::{Gc, GcCell, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{ExprLocation, Visibility};6use rustc_hash::{FxHashMap, FxHashSet, FxHasher};7use std::collections::HashMap;8use std::hash::{Hash, Hasher};9use std::{fmt::Debug, hash::BuildHasherDefault};1011#[derive(Debug, Trace)]12#[trivially_drop]13pub struct ObjMember {14	pub add: bool,15	pub visibility: Visibility,16	pub invoke: LazyBinding,17	pub location: Option<ExprLocation>,18}1920pub trait ObjectAssertion: Trace {21	fn run(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<()>;22}2324// Field => This25type CacheKey = (IStr, ObjValue);26#[derive(Trace)]27#[trivially_drop]28pub struct ObjValueInternals {29	super_obj: Option<ObjValue>,30	assertions: Gc<Vec<Box<dyn ObjectAssertion>>>,31	assertions_ran: GcCell<FxHashSet<ObjValue>>,32	this_obj: Option<ObjValue>,33	this_entries: Gc<FxHashMap<IStr, ObjMember>>,34	value_cache: GcCell<FxHashMap<CacheKey, Option<Val>>>,35}3637#[derive(Clone, Trace)]38#[trivially_drop]39pub struct ObjValue(pub(crate) Gc<ObjValueInternals>);40impl Debug for ObjValue {41	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {42		if let Some(super_obj) = self.0.super_obj.as_ref() {43			if f.alternate() {44				write!(f, "{:#?}", super_obj)?;45			} else {46				write!(f, "{:?}", super_obj)?;47			}48			write!(f, " + ")?;49		}50		let mut debug = f.debug_struct("ObjValue");51		for (name, member) in self.0.this_entries.iter() {52			debug.field(name, member);53		}54		#[cfg(feature = "unstable")]55		{56			debug.finish_non_exhaustive()57		}58		#[cfg(not(feature = "unstable"))]59		{60			debug.finish()61		}62	}63}6465impl ObjValue {66	pub fn new(67		super_obj: Option<Self>,68		this_entries: Gc<FxHashMap<IStr, ObjMember>>,69		assertions: Gc<Vec<Box<dyn ObjectAssertion>>>,70	) -> Self {71		Self(Gc::new(ObjValueInternals {72			super_obj,73			assertions,74			assertions_ran: GcCell::new(FxHashSet::default()),75			this_obj: None,76			this_entries,77			value_cache: GcCell::new(FxHashMap::default()),78		}))79	}80	pub fn new_empty() -> Self {81		Self::new(None, Gc::new(FxHashMap::default()), Gc::new(Vec::new()))82	}83	pub fn extend_from(&self, super_obj: Self) -> Self {84		match &self.0.super_obj {85			None => Self::new(86				Some(super_obj),87				self.0.this_entries.clone(),88				self.0.assertions.clone(),89			),90			Some(v) => Self::new(91				Some(v.extend_from(super_obj)),92				self.0.this_entries.clone(),93				self.0.assertions.clone(),94			),95		}96	}97	pub fn with_this(&self, this_obj: Self) -> Self {98		Self(Gc::new(ObjValueInternals {99			super_obj: self.0.super_obj.clone(),100			assertions: self.0.assertions.clone(),101			assertions_ran: GcCell::new(FxHashSet::default()),102			this_obj: Some(this_obj),103			this_entries: self.0.this_entries.clone(),104			value_cache: GcCell::new(FxHashMap::default()),105		}))106	}107108	/// Run callback for every field found in object109	pub(crate) fn enum_fields(&self, handler: &mut impl FnMut(&IStr, &Visibility) -> bool) -> bool {110		if let Some(s) = &self.0.super_obj {111			if s.enum_fields(handler) {112				return true;113			}114		}115		for (name, member) in self.0.this_entries.iter() {116			if handler(name, &member.visibility) {117				return true;118			}119		}120		false121	}122123	pub fn fields_visibility(&self) -> FxHashMap<IStr, bool> {124		let mut out = FxHashMap::default();125		self.enum_fields(&mut |name, visibility| {126			match visibility {127				Visibility::Normal => {128					let entry = out.entry(name.to_owned());129					entry.or_insert(true);130				}131				Visibility::Hidden => {132					out.insert(name.to_owned(), false);133				}134				Visibility::Unhide => {135					out.insert(name.to_owned(), true);136				}137			};138			false139		});140		out141	}142	pub fn fields_ex(&self, include_hidden: bool) -> Vec<IStr> {143		let mut fields: Vec<_> = self144			.fields_visibility()145			.into_iter()146			.filter(|(_k, v)| include_hidden || *v)147			.map(|(k, _)| k)148			.collect();149		fields.sort_unstable();150		fields151	}152	pub fn fields(&self) -> Vec<IStr> {153		self.fields_ex(false)154	}155156	pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {157		if let Some(m) = self.0.this_entries.get(&name) {158			Some(match &m.visibility {159				Visibility::Normal => self160					.0161					.super_obj162					.as_ref()163					.and_then(|super_obj| super_obj.field_visibility(name))164					.unwrap_or(Visibility::Normal),165				v => *v,166			})167		} else if let Some(super_obj) = &self.0.super_obj {168			super_obj.field_visibility(name)169		} else {170			None171		}172	}173174	fn has_field_include_hidden(&self, name: IStr) -> bool {175		if self.0.this_entries.contains_key(&name) {176			true177		} else if let Some(super_obj) = &self.0.super_obj {178			super_obj.has_field_include_hidden(name)179		} else {180			false181		}182	}183184	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {185		if include_hidden {186			self.has_field_include_hidden(name)187		} else {188			self.has_field(name)189		}190	}191	pub fn has_field(&self, name: IStr) -> bool {192		self.field_visibility(name)193			.map(|v| v.is_visible())194			.unwrap_or(false)195	}196197	pub fn get(&self, key: IStr) -> Result<Option<Val>> {198		self.run_assertions()?;199		self.get_raw(key, self.0.this_obj.as_ref())200	}201202	pub fn extend_with_field(self, key: IStr, value: ObjMember) -> Self {203		let mut new = FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());204		new.insert(key, value);205		Self::new(Some(self), Gc::new(new), Gc::new(Vec::new()))206	}207208	fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {209		let real_this = real_this.unwrap_or(self);210		let cache_key = (key.clone(), real_this.clone());211212		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {213			return Ok(v.clone());214		}215		let value = match (self.0.this_entries.get(&key), &self.0.super_obj) {216			(Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),217			(Some(k), Some(s)) => {218				let our = self.evaluate_this(k, real_this)?;219				if k.add {220					s.get_raw(key, Some(real_this))?221						.map_or(Ok(Some(our.clone())), |v| {222							Ok(Some(evaluate_add_op(&v, &our)?))223						})224				} else {225					Ok(Some(our))226				}227			}228			(None, Some(s)) => s.get_raw(key, Some(real_this)),229			(None, None) => Ok(None),230		}?;231		self.0232			.value_cache233			.borrow_mut()234			.insert(cache_key, value.clone());235		Ok(value)236	}237	fn evaluate_this(&self, v: &ObjMember, real_this: &Self) -> Result<Val> {238		v.invoke239			.evaluate(Some(real_this.clone()), self.0.super_obj.clone())?240			.evaluate()241	}242243	fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {244		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {245			for assertion in self.0.assertions.iter() {246				if let Err(e) = assertion.run(Some(real_this.clone()), self.0.super_obj.clone()) {247					self.0.assertions_ran.borrow_mut().remove(real_this);248					return Err(e);249				}250			}251			if let Some(super_obj) = &self.0.super_obj {252				super_obj.run_assertions_raw(real_this)?;253			}254		}255		Ok(())256	}257	pub fn run_assertions(&self) -> Result<()> {258		self.run_assertions_raw(self)259	}260261	pub fn ptr_eq(a: &Self, b: &Self) -> bool {262		Gc::ptr_eq(&a.0, &b.0)263	}264}265266impl PartialEq for ObjValue {267	fn eq(&self, other: &Self) -> bool {268		Gc::ptr_eq(&self.0, &other.0)269	}270}271272impl Eq for ObjValue {}273impl Hash for ObjValue {274	fn hash<H: Hasher>(&self, hasher: &mut H) {275		hasher.write_usize(&*self.0 as *const _ as usize)276	}277}278279pub struct ObjValueBuilder {280	super_obj: Option<ObjValue>,281	map: FxHashMap<IStr, ObjMember>,282	assertions: Vec<Box<dyn ObjectAssertion>>,283}284impl ObjValueBuilder {285	pub fn new() -> Self {286		Self::with_capacity(0)287	}288	pub fn with_capacity(capacity: usize) -> Self {289		Self {290			super_obj: None,291			map: HashMap::with_capacity_and_hasher(292				capacity,293				BuildHasherDefault::<FxHasher>::default(),294			),295			assertions: Vec::new(),296		}297	}298	pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {299		self.assertions.reserve_exact(capacity);300		self301	}302	pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {303		self.super_obj = Some(super_obj);304		self305	}306307	pub fn assert(&mut self, assertion: Box<dyn ObjectAssertion>) -> &mut Self {308		self.assertions.push(assertion);309		self310	}311	pub fn member(&mut self, name: IStr) -> ObjMemberBuilder {312		ObjMemberBuilder {313			value: self,314			name,315			add: false,316			visibility: Visibility::Normal,317			location: None,318		}319	}320321	pub fn build(self) -> ObjValue {322		ObjValue::new(self.super_obj, Gc::new(self.map), Gc::new(self.assertions))323	}324}325impl Default for ObjValueBuilder {326	fn default() -> Self {327		Self::with_capacity(0)328	}329}330331#[must_use = "value not added unless binding() was called"]332pub struct ObjMemberBuilder<'v> {333	value: &'v mut ObjValueBuilder,334	name: IStr,335	add: bool,336	visibility: Visibility,337	location: Option<ExprLocation>,338}339340#[allow(clippy::missing_const_for_fn)]341impl<'v> ObjMemberBuilder<'v> {342	pub const fn with_add(mut self, add: bool) -> Self {343		self.add = add;344		self345	}346	pub fn add(self) -> Self {347		self.with_add(true)348	}349	pub fn with_visibility(mut self, visibility: Visibility) -> Self {350		self.visibility = visibility;351		self352	}353	pub fn hide(self) -> Self {354		self.with_visibility(Visibility::Hidden)355	}356	pub fn with_location(mut self, location: Option<ExprLocation>) -> Self {357		self.location = location;358		self359	}360	pub fn value(self, value: Val) -> &'v mut ObjValueBuilder {361		self.binding(LazyBinding::Bound(LazyVal::new_resolved(value)))362	}363	pub fn bindable(self, bindable: Box<dyn Bindable>) -> &'v mut ObjValueBuilder {364		self.binding(LazyBinding::Bindable(Gc::new(bindable)))365	}366	pub fn binding(self, binding: LazyBinding) -> &'v mut ObjValueBuilder {367		self.value.map.insert(368			self.name,369			ObjMember {370				add: self.add,371				visibility: self.visibility,372				invoke: binding,373				location: self.location,374			},375		);376		self.value377	}378}