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

1use crate::operator::evaluate_add_op;2use crate::{LazyBinding, Result, Val};3use jrsonnet_gc::{Gc, GcCell, Trace};4use jrsonnet_interner::IStr;5use jrsonnet_parser::{ExprLocation, Visibility};6use rustc_hash::{FxHashMap, FxHashSet};7use std::hash::{Hash, Hasher};8use std::{fmt::Debug, hash::BuildHasherDefault};910#[derive(Debug, Trace)]11#[trivially_drop]12pub struct ObjMember {13	pub add: bool,14	pub visibility: Visibility,15	pub invoke: LazyBinding,16	pub location: Option<ExprLocation>,17}1819pub trait ObjectAssertion: Trace {20	fn run(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<()>;21}2223// Field => This24type CacheKey = (IStr, ObjValue);25#[derive(Trace)]26#[trivially_drop]27pub struct ObjValueInternals {28	super_obj: Option<ObjValue>,29	assertions: Gc<Vec<Box<dyn ObjectAssertion>>>,30	assertions_ran: GcCell<FxHashSet<ObjValue>>,31	this_obj: Option<ObjValue>,32	this_entries: Gc<FxHashMap<IStr, ObjMember>>,33	value_cache: GcCell<FxHashMap<CacheKey, Option<Val>>>,34}3536#[derive(Clone, Trace)]37#[trivially_drop]38pub struct ObjValue(pub(crate) Gc<ObjValueInternals>);39impl Debug for ObjValue {40	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {41		if let Some(super_obj) = self.0.super_obj.as_ref() {42			if f.alternate() {43				write!(f, "{:#?}", super_obj)?;44			} else {45				write!(f, "{:?}", super_obj)?;46			}47			write!(f, " + ")?;48		}49		let mut debug = f.debug_struct("ObjValue");50		for (name, member) in self.0.this_entries.iter() {51			debug.field(name, member);52		}53		#[cfg(feature = "unstable")]54		{55			debug.finish_non_exhaustive()56		}57		#[cfg(not(feature = "unstable"))]58		{59			debug.finish()60		}61	}62}6364impl ObjValue {65	pub fn new(66		super_obj: Option<Self>,67		this_entries: Gc<FxHashMap<IStr, ObjMember>>,68		assertions: Gc<Vec<Box<dyn ObjectAssertion>>>,69	) -> Self {70		Self(Gc::new(ObjValueInternals {71			super_obj,72			assertions,73			assertions_ran: GcCell::new(FxHashSet::default()),74			this_obj: None,75			this_entries,76			value_cache: GcCell::new(FxHashMap::default()),77		}))78	}79	pub fn new_empty() -> Self {80		Self::new(None, Gc::new(FxHashMap::default()), Gc::new(Vec::new()))81	}82	pub fn extend_from(&self, super_obj: Self) -> Self {83		match &self.0.super_obj {84			None => Self::new(85				Some(super_obj),86				self.0.this_entries.clone(),87				self.0.assertions.clone(),88			),89			Some(v) => Self::new(90				Some(v.extend_from(super_obj)),91				self.0.this_entries.clone(),92				self.0.assertions.clone(),93			),94		}95	}96	pub fn with_this(&self, this_obj: Self) -> Self {97		Self(Gc::new(ObjValueInternals {98			super_obj: self.0.super_obj.clone(),99			assertions: self.0.assertions.clone(),100			assertions_ran: GcCell::new(FxHashSet::default()),101			this_obj: Some(this_obj),102			this_entries: self.0.this_entries.clone(),103			value_cache: GcCell::new(FxHashMap::default()),104		}))105	}106107	/// Run callback for every field found in object108	pub(crate) fn enum_fields(&self, handler: &mut impl FnMut(&IStr, &Visibility) -> bool) -> bool {109		if let Some(s) = &self.0.super_obj {110			if s.enum_fields(handler) {111				return true;112			}113		}114		for (name, member) in self.0.this_entries.iter() {115			if handler(name, &member.visibility) {116				return true;117			}118		}119		false120	}121122	pub fn fields_visibility(&self) -> FxHashMap<IStr, bool> {123		let mut out = FxHashMap::default();124		self.enum_fields(&mut |name, visibility| {125			match visibility {126				Visibility::Normal => {127					let entry = out.entry(name.to_owned());128					entry.or_insert(true);129				}130				Visibility::Hidden => {131					out.insert(name.to_owned(), false);132				}133				Visibility::Unhide => {134					out.insert(name.to_owned(), true);135				}136			};137			false138		});139		out140	}141	pub fn fields_ex(&self, include_hidden: bool) -> Vec<IStr> {142		let mut fields: Vec<_> = self143			.fields_visibility()144			.into_iter()145			.filter(|(_k, v)| include_hidden || *v)146			.map(|(k, _)| k)147			.collect();148		fields.sort_unstable();149		fields150	}151	pub fn fields(&self) -> Vec<IStr> {152		self.fields_ex(false)153	}154155	pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {156		if let Some(m) = self.0.this_entries.get(&name) {157			Some(match &m.visibility {158				Visibility::Normal => self159					.0160					.super_obj161					.as_ref()162					.and_then(|super_obj| super_obj.field_visibility(name))163					.unwrap_or(Visibility::Normal),164				v => *v,165			})166		} else if let Some(super_obj) = &self.0.super_obj {167			super_obj.field_visibility(name)168		} else {169			None170		}171	}172173	fn has_field_include_hidden(&self, name: IStr) -> bool {174		if self.0.this_entries.contains_key(&name) {175			true176		} else if let Some(super_obj) = &self.0.super_obj {177			super_obj.has_field_include_hidden(name)178		} else {179			false180		}181	}182183	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {184		if include_hidden {185			self.has_field_include_hidden(name)186		} else {187			self.has_field(name)188		}189	}190	pub fn has_field(&self, name: IStr) -> bool {191		self.field_visibility(name)192			.map(|v| v.is_visible())193			.unwrap_or(false)194	}195196	pub fn get(&self, key: IStr) -> Result<Option<Val>> {197		self.run_assertions()?;198		self.get_raw(key, self.0.this_obj.as_ref())199	}200201	pub fn extend_with_field(self, key: IStr, value: ObjMember) -> Self {202		let mut new = FxHashMap::with_capacity_and_hasher(1, BuildHasherDefault::default());203		new.insert(key, value);204		Self::new(Some(self), Gc::new(new), Gc::new(Vec::new()))205	}206207	fn get_raw(&self, key: IStr, real_this: Option<&Self>) -> Result<Option<Val>> {208		let real_this = real_this.unwrap_or(self);209		let cache_key = (key.clone(), real_this.clone());210211		if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {212			return Ok(v.clone());213		}214		let value = match (self.0.this_entries.get(&key), &self.0.super_obj) {215			(Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),216			(Some(k), Some(s)) => {217				let our = self.evaluate_this(k, real_this)?;218				if k.add {219					s.get_raw(key, Some(real_this))?220						.map_or(Ok(Some(our.clone())), |v| {221							Ok(Some(evaluate_add_op(&v, &our)?))222						})223				} else {224					Ok(Some(our))225				}226			}227			(None, Some(s)) => s.get_raw(key, Some(real_this)),228			(None, None) => Ok(None),229		}?;230		self.0231			.value_cache232			.borrow_mut()233			.insert(cache_key, value.clone());234		Ok(value)235	}236	fn evaluate_this(&self, v: &ObjMember, real_this: &Self) -> Result<Val> {237		v.invoke238			.evaluate(Some(real_this.clone()), self.0.super_obj.clone())?239			.evaluate()240	}241242	fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {243		if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {244			for assertion in self.0.assertions.iter() {245				if let Err(e) = assertion.run(Some(real_this.clone()), self.0.super_obj.clone()) {246					self.0.assertions_ran.borrow_mut().remove(real_this);247					return Err(e);248				}249			}250			if let Some(super_obj) = &self.0.super_obj {251				super_obj.run_assertions_raw(real_this)?;252			}253		}254		Ok(())255	}256	pub fn run_assertions(&self) -> Result<()> {257		self.run_assertions_raw(self)258	}259260	pub fn ptr_eq(a: &Self, b: &Self) -> bool {261		Gc::ptr_eq(&a.0, &b.0)262	}263}264265impl PartialEq for ObjValue {266	fn eq(&self, other: &Self) -> bool {267		Gc::ptr_eq(&self.0, &other.0)268	}269}270271impl Eq for ObjValue {}272impl Hash for ObjValue {273	fn hash<H: Hasher>(&self, hasher: &mut H) {274		hasher.write_usize(&*self.0 as *const _ as usize)275	}276}