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, MaybeUnbound, Result, State, Thunk, Unbound, Val,19};2021#[cfg(not(feature = "exp-preserve-order"))]22mod ordering {23 #![allow(24 25 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::{Ordering, 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 match self.0 .0.cmp(&other.0 .0) {85 Ordering::Greater => self,86 Ordering::Less => other,87 Ordering::Equal => unreachable!("object can't have two fields with the same name"),88 }89 }90 }91}9293use ordering::*;9495#[allow(clippy::module_name_repetitions)]96#[derive(Debug, Trace)]97pub struct ObjMember {98 pub add: bool,99 pub visibility: Visibility,100 original_index: FieldIndex,101 pub invoke: MaybeUnbound,102 pub location: Option<ExprLocation>,103}104105pub trait ObjectAssertion: Trace {106 fn run(&self, super_obj: Option<ObjValue>, this: Option<ObjValue>) -> Result<()>;107}108109110111#[derive(Trace)]112enum CacheValue {113 Cached(Val),114 NotFound,115 Pending,116 Errored(Error),117}118119#[allow(clippy::module_name_repetitions)]120#[derive(Trace)]121#[trace(tracking(force))]122pub struct ObjValueInternals {123 sup: Option<ObjValue>,124 this: Option<ObjValue>,125126 assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,127 assertions_ran: RefCell<GcHashSet<ObjValue>>,128 this_entries: Cc<GcHashMap<IStr, ObjMember>>,129 value_cache: RefCell<GcHashMap<(IStr, Option<WeakObjValue>), CacheValue>>,130}131132#[derive(Clone, Trace)]133pub struct WeakObjValue(#[trace(skip)] pub(crate) Weak<ObjValueInternals>);134135impl PartialEq for WeakObjValue {136 fn eq(&self, other: &Self) -> bool {137 Weak::ptr_eq(&self.0, &other.0)138 }139}140141impl Eq for WeakObjValue {}142impl Hash for WeakObjValue {143 fn hash<H: Hasher>(&self, hasher: &mut H) {144 145 let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };146 hasher.write_usize(addr);147 }148}149150#[allow(clippy::module_name_repetitions)]151#[derive(Clone, Trace)]152pub struct ObjValue(pub(crate) Cc<ObjValueInternals>);153impl Debug for ObjValue {154 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {155 if let Some(super_obj) = self.0.sup.as_ref() {156 if f.alternate() {157 write!(f, "{super_obj:#?}")?;158 } else {159 write!(f, "{super_obj:?}")?;160 }161 write!(f, " + ")?;162 }163 let mut debug = f.debug_struct("ObjValue");164 for (name, member) in self.0.this_entries.iter() {165 debug.field(name, member);166 }167 debug.finish_non_exhaustive()168 }169}170171impl ObjValue {172 pub fn new(173 sup: Option<Self>,174 this_entries: Cc<GcHashMap<IStr, ObjMember>>,175 assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,176 ) -> Self {177 Self(Cc::new(ObjValueInternals {178 sup,179 this: None,180 assertions,181 assertions_ran: RefCell::new(GcHashSet::new()),182 this_entries,183 value_cache: RefCell::new(GcHashMap::new()),184 }))185 }186 pub fn new_empty() -> Self {187 Self::new(None, Cc::new(GcHashMap::new()), Cc::new(Vec::new()))188 }189 pub fn builder() -> ObjValueBuilder {190 ObjValueBuilder::new()191 }192 pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {193 ObjValueBuilder::with_capacity(capacity)194 }195 #[must_use]196 pub fn extend_from(&self, sup: Self) -> Self {197 match &self.0.sup {198 None => Self::new(199 Some(sup),200 self.0.this_entries.clone(),201 self.0.assertions.clone(),202 ),203 Some(v) => Self::new(204 Some(v.extend_from(sup)),205 self.0.this_entries.clone(),206 self.0.assertions.clone(),207 ),208 }209 }210 pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {211 let mut new = GcHashMap::with_capacity(1);212 new.insert(key, value);213 Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))214 }215 pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {216 ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())217 }218219 #[must_use]220 pub fn with_this(&self, this: Self) -> Self {221 Self(Cc::new(ObjValueInternals {222 sup: self.0.sup.clone(),223 assertions: self.0.assertions.clone(),224 assertions_ran: RefCell::new(GcHashSet::new()),225 this: Some(this),226 this_entries: self.0.this_entries.clone(),227 value_cache: RefCell::new(GcHashMap::new()),228 }))229 }230231 pub fn len(&self) -> usize {232 self.fields_visibility()233 .into_iter()234 .filter(|(_, (visible, _))| *visible)235 .count()236 }237238 pub fn is_empty(&self) -> bool {239 if !self.0.this_entries.is_empty() {240 return false;241 }242 self.0.sup.as_ref().map_or(true, Self::is_empty)243 }244245 246 247 248 pub(crate) fn enum_fields(249 &self,250 depth: SuperDepth,251 handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,252 ) -> bool {253 if let Some(s) = &self.0.sup {254 if s.enum_fields(depth.deeper(), handler) {255 return true;256 }257 }258 for (name, member) in self.0.this_entries.iter() {259 if handler(depth, name, member) {260 return true;261 }262 }263 false264 }265266 pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {267 let mut out = FxHashMap::default();268 self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {269 let new_sort_key = FieldSortKey::new(depth, member.original_index);270 let entry = out.entry(name.clone());271 let (visible, _) = entry.or_insert((true, new_sort_key));272 match member.visibility {273 Visibility::Normal => {}274 Visibility::Hidden => {275 *visible = false;276 }277 Visibility::Unhide => {278 *visible = true;279 }280 };281 false282 });283 out284 }285 pub fn fields_ex(286 &self,287 include_hidden: bool,288 #[cfg(feature = "exp-preserve-order")] preserve_order: bool,289 ) -> Vec<IStr> {290 #[cfg(feature = "exp-preserve-order")]291 if preserve_order {292 let (mut fields, mut keys): (Vec<_>, Vec<_>) = self293 .fields_visibility()294 .into_iter()295 .filter(|(_, (visible, _))| include_hidden || *visible)296 .enumerate()297 .map(|(idx, (k, (_, sk)))| (k, (sk, idx)))298 .unzip();299 keys.sort_unstable_by_key(|v| v.0);300 301 for i in 0..fields.len() {302 let x = fields[i].clone();303 let mut j = i;304 loop {305 let k = keys[j].1;306 keys[j].1 = j;307 if k == i {308 break;309 }310 fields[j] = fields[k].clone();311 j = k;312 }313 fields[j] = x;314 }315 return fields;316 }317318 let mut fields: Vec<_> = self319 .fields_visibility()320 .into_iter()321 .filter(|(_, (visible, _))| include_hidden || *visible)322 .map(|(k, _)| k)323 .collect();324 fields.sort_unstable();325 fields326 }327 pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {328 self.fields_ex(329 false,330 #[cfg(feature = "exp-preserve-order")]331 preserve_order,332 )333 }334335 pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {336 if let Some(m) = self.0.this_entries.get(&name) {337 Some(match &m.visibility {338 Visibility::Normal => self339 .0340 .sup341 .as_ref()342 .and_then(|super_obj| super_obj.field_visibility(name))343 .unwrap_or(Visibility::Normal),344 v => *v,345 })346 } else if let Some(super_obj) = &self.0.sup {347 super_obj.field_visibility(name)348 } else {349 None350 }351 }352353 fn has_field_include_hidden(&self, name: IStr) -> bool {354 if self.0.this_entries.contains_key(&name) {355 true356 } else if let Some(super_obj) = &self.0.sup {357 super_obj.has_field_include_hidden(name)358 } else {359 false360 }361 }362363 pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {364 if include_hidden {365 self.has_field_include_hidden(name)366 } else {367 self.has_field(name)368 }369 }370 pub fn has_field(&self, name: IStr) -> bool {371 self.field_visibility(name)372 .map_or(false, |v| v.is_visible())373 }374375 pub fn iter(376 &self,377 #[cfg(feature = "exp-preserve-order")] preserve_order: bool,378 ) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {379 let fields = self.fields(380 #[cfg(feature = "exp-preserve-order")]381 preserve_order,382 );383 fields.into_iter().map(|field| {384 (385 field.clone(),386 self.get(field)387 .map(|opt| opt.expect("iterating over keys, field exists")),388 )389 })390 }391392 pub fn get(&self, key: IStr) -> Result<Option<Val>> {393 self.run_assertions()?;394 let cache_key = (key.clone(), None);395 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {396 return Ok(match v {397 CacheValue::Cached(v) => Some(v.clone()),398 CacheValue::NotFound => None,399 CacheValue::Pending => throw!(InfiniteRecursionDetected),400 CacheValue::Errored(e) => return Err(e.clone()),401 });402 }403 self.0404 .value_cache405 .borrow_mut()406 .insert(cache_key.clone(), CacheValue::Pending);407 let value = self408 .get_raw(key, self.0.this.clone().unwrap_or_else(|| self.clone()))409 .map_err(|e| {410 self.0411 .value_cache412 .borrow_mut()413 .insert(cache_key.clone(), CacheValue::Errored(e.clone()));414 e415 })?;416 self.0.value_cache.borrow_mut().insert(417 cache_key,418 value419 .as_ref()420 .map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),421 );422 Ok(value)423 }424 pub fn get_for(&self, key: IStr, this: Self) -> Result<Option<Val>> {425 self.run_assertions()?;426 let cache_key = (key.clone(), Some(this.clone().downgrade()));427 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {428 return Ok(match v {429 CacheValue::Cached(v) => Some(v.clone()),430 CacheValue::NotFound => None,431 CacheValue::Pending => throw!(InfiniteRecursionDetected),432 CacheValue::Errored(e) => return Err(e.clone()),433 });434 }435 self.0436 .value_cache437 .borrow_mut()438 .insert(cache_key.clone(), CacheValue::Pending);439 let value = self.get_raw(key, this).map_err(|e| {440 self.0441 .value_cache442 .borrow_mut()443 .insert(cache_key.clone(), CacheValue::Errored(e.clone()));444 e445 })?;446 self.0.value_cache.borrow_mut().insert(447 cache_key,448 value449 .as_ref()450 .map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),451 );452 Ok(value)453 }454455 fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {456 match (self.0.this_entries.get(&key), &self.0.sup) {457 (Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),458 (Some(k), Some(super_obj)) => {459 let our = self.evaluate_this(k, real_this.clone())?;460 if k.add {461 super_obj462 .get_raw(key, real_this)?463 .map_or(Ok(Some(our.clone())), |v| {464 Ok(Some(evaluate_add_op(&v, &our)?))465 })466 } else {467 Ok(Some(our))468 }469 }470 (None, Some(super_obj)) => super_obj.get_raw(key, real_this),471 (None, None) => Ok(None),472 }473 }474 fn evaluate_this(&self, v: &ObjMember, real_this: Self) -> Result<Val> {475 v.invoke.evaluate(self.0.sup.clone(), Some(real_this))476 }477478 fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {479 if self.0.assertions.is_empty() {480 if let Some(super_obj) = &self.0.sup {481 super_obj.run_assertions_raw(real_this)?;482 }483 return Ok(());484 }485 if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {486 for assertion in self.0.assertions.iter() {487 if let Err(e) = assertion.run(self.0.sup.clone(), Some(real_this.clone())) {488 self.0.assertions_ran.borrow_mut().remove(real_this);489 return Err(e);490 }491 }492 if let Some(super_obj) = &self.0.sup {493 super_obj.run_assertions_raw(real_this)?;494 }495 }496 Ok(())497 }498 pub fn run_assertions(&self) -> Result<()> {499 self.run_assertions_raw(self)500 }501502 pub fn ptr_eq(a: &Self, b: &Self) -> bool {503 Cc::ptr_eq(&a.0, &b.0)504 }505 pub fn downgrade(self) -> WeakObjValue {506 WeakObjValue(self.0.downgrade())507 }508}509510impl PartialEq for ObjValue {511 fn eq(&self, other: &Self) -> bool {512 Cc::ptr_eq(&self.0, &other.0)513 }514}515516impl Eq for ObjValue {}517impl Hash for ObjValue {518 fn hash<H: Hasher>(&self, hasher: &mut H) {519 hasher.write_usize(addr_of!(*self.0) as usize);520 }521}522523#[allow(clippy::module_name_repetitions)]524pub struct ObjValueBuilder {525 sup: Option<ObjValue>,526 map: GcHashMap<IStr, ObjMember>,527 assertions: Vec<TraceBox<dyn ObjectAssertion>>,528 next_field_index: FieldIndex,529}530impl ObjValueBuilder {531 pub fn new() -> Self {532 Self::with_capacity(0)533 }534 pub fn with_capacity(capacity: usize) -> Self {535 Self {536 sup: None,537 map: GcHashMap::with_capacity(capacity),538 assertions: Vec::new(),539 next_field_index: FieldIndex::default(),540 }541 }542 pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {543 self.assertions.reserve_exact(capacity);544 self545 }546 pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {547 self.sup = Some(super_obj);548 self549 }550551 pub fn assert(&mut self, assertion: impl ObjectAssertion + 'static) -> &mut Self {552 self.assertions.push(tb!(assertion));553 self554 }555 pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {556 let field_index = self.next_field_index;557 self.next_field_index = self.next_field_index.next();558 ObjMemberBuilder::new(ValueBuilder(self), name, field_index)559 }560561 pub fn build(self) -> ObjValue {562 ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))563 }564}565impl Default for ObjValueBuilder {566 fn default() -> Self {567 Self::with_capacity(0)568 }569}570571#[allow(clippy::module_name_repetitions)]572#[must_use = "value not added unless binding() was called"]573pub struct ObjMemberBuilder<Kind> {574 kind: Kind,575 name: IStr,576 add: bool,577 visibility: Visibility,578 original_index: FieldIndex,579 location: Option<ExprLocation>,580}581582#[allow(clippy::missing_const_for_fn)]583impl<Kind> ObjMemberBuilder<Kind> {584 pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {585 Self {586 kind,587 name,588 original_index,589 add: false,590 visibility: Visibility::Normal,591 location: None,592 }593 }594595 pub const fn with_add(mut self, add: bool) -> Self {596 self.add = add;597 self598 }599 pub fn add(self) -> Self {600 self.with_add(true)601 }602 pub fn with_visibility(mut self, visibility: Visibility) -> Self {603 self.visibility = visibility;604 self605 }606 pub fn hide(self) -> Self {607 self.with_visibility(Visibility::Hidden)608 }609 pub fn with_location(mut self, location: ExprLocation) -> Self {610 self.location = Some(location);611 self612 }613 fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {614 (615 self.kind,616 self.name,617 ObjMember {618 add: self.add,619 visibility: self.visibility,620 original_index: self.original_index,621 invoke: binding,622 location: self.location,623 },624 )625 }626}627628pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);629impl ObjMemberBuilder<ValueBuilder<'_>> {630 631 pub fn value_unchecked(self, value: Val) {632 let (receiver, name, member) =633 self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value)));634 let entry = receiver.0.map.entry(name);635 entry.insert(member);636 }637638 pub fn value(self, value: Val) -> Result<()> {639 self.thunk(Thunk::evaluated(value))640 }641 pub fn thunk(self, value: Thunk<Val>) -> Result<()> {642 self.binding(MaybeUnbound::Bound(value))643 }644 pub fn bindable(self, bindable: impl Unbound<Bound = Val>) -> Result<()> {645 self.binding(MaybeUnbound::Unbound(Cc::new(tb!(bindable))))646 }647 pub fn binding(self, binding: MaybeUnbound) -> Result<()> {648 let (receiver, name, member) = self.build_member(binding);649 let location = member.location.clone();650 let old = receiver.0.map.insert(name.clone(), member);651 if old.is_some() {652 State::push(653 CallLocation(location.as_ref()),654 || format!("field <{}> initializtion", name.clone()),655 || throw!(DuplicateFieldName(name.clone())),656 )?;657 }658 Ok(())659 }660}661662pub struct ExtendBuilder<'v>(&'v mut ObjValue);663impl ObjMemberBuilder<ExtendBuilder<'_>> {664 pub fn value(self, value: Val) {665 self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));666 }667 pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Val>>) {668 self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));669 }670 pub fn binding(self, binding: MaybeUnbound) {671 let (receiver, name, member) = self.build_member(binding);672 let new = receiver.0.clone();673 *receiver.0 = new.extend_with_raw_member(name, member);674 }675}