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}222324type 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 108 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}