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::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: MaybeUnbound,104 pub location: Option<ExprLocation>,105}106107pub trait ObjectAssertion: Trace {108 fn run(&self, super_obj: Option<ObjValue>, this: Option<ObjValue>) -> Result<()>;109}110111112113#[derive(Trace)]114enum CacheValue {115 Cached(Val),116 NotFound,117 Pending,118 Errored(Error),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, Option<WeakObjValue>), 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 147 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 242 243 244 pub(crate) fn enum_fields(245 &self,246 depth: SuperDepth,247 handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,248 ) -> bool {249 if let Some(s) = &self.0.sup {250 if s.enum_fields(depth.deeper(), handler) {251 return true;252 }253 }254 for (name, member) in self.0.this_entries.iter() {255 if handler(depth, name, member) {256 return true;257 }258 }259 false260 }261262 pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {263 let mut out = FxHashMap::default();264 self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {265 let new_sort_key = FieldSortKey::new(depth, member.original_index);266 let entry = out.entry(name.clone());267 let (visible, _) = entry.or_insert((true, new_sort_key));268 match member.visibility {269 Visibility::Normal => {}270 Visibility::Hidden => {271 *visible = false;272 }273 Visibility::Unhide => {274 *visible = true;275 }276 };277 false278 });279 out280 }281 pub fn fields_ex(282 &self,283 include_hidden: bool,284 #[cfg(feature = "exp-preserve-order")] preserve_order: bool,285 ) -> Vec<IStr> {286 #[cfg(feature = "exp-preserve-order")]287 if preserve_order {288 let (mut fields, mut keys): (Vec<_>, Vec<_>) = self289 .fields_visibility()290 .into_iter()291 .filter(|(_, (visible, _))| include_hidden || *visible)292 .enumerate()293 .map(|(idx, (k, (_, sk)))| (k, (sk, idx)))294 .unzip();295 keys.sort_unstable_by_key(|v| v.0);296 297 for i in 0..fields.len() {298 let x = fields[i].clone();299 let mut j = i;300 loop {301 let k = keys[j].1;302 keys[j].1 = j;303 if k == i {304 break;305 }306 fields[j] = fields[k].clone();307 j = k308 }309 fields[j] = x;310 }311 return fields;312 }313314 let mut fields: Vec<_> = self315 .fields_visibility()316 .into_iter()317 .filter(|(_, (visible, _))| include_hidden || *visible)318 .map(|(k, _)| k)319 .collect();320 fields.sort_unstable();321 fields322 }323 pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {324 self.fields_ex(325 false,326 #[cfg(feature = "exp-preserve-order")]327 preserve_order,328 )329 }330331 pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {332 if let Some(m) = self.0.this_entries.get(&name) {333 Some(match &m.visibility {334 Visibility::Normal => self335 .0336 .sup337 .as_ref()338 .and_then(|super_obj| super_obj.field_visibility(name))339 .unwrap_or(Visibility::Normal),340 v => *v,341 })342 } else if let Some(super_obj) = &self.0.sup {343 super_obj.field_visibility(name)344 } else {345 None346 }347 }348349 fn has_field_include_hidden(&self, name: IStr) -> bool {350 if self.0.this_entries.contains_key(&name) {351 true352 } else if let Some(super_obj) = &self.0.sup {353 super_obj.has_field_include_hidden(name)354 } else {355 false356 }357 }358359 pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {360 if include_hidden {361 self.has_field_include_hidden(name)362 } else {363 self.has_field(name)364 }365 }366 pub fn has_field(&self, name: IStr) -> bool {367 self.field_visibility(name)368 .map_or(false, |v| v.is_visible())369 }370371 pub fn iter(372 &self,373 #[cfg(feature = "exp-preserve-order")] preserve_order: bool,374 ) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {375 let fields = self.fields(376 #[cfg(feature = "exp-preserve-order")]377 preserve_order,378 );379 fields.into_iter().map(|field| {380 (381 field.clone(),382 self.get(field)383 .map(|opt| opt.expect("iterating over keys, field exists")),384 )385 })386 }387388 pub fn get(&self, key: IStr) -> Result<Option<Val>> {389 self.run_assertions()?;390 let cache_key = (key.clone(), None);391 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {392 return Ok(match v {393 CacheValue::Cached(v) => Some(v.clone()),394 CacheValue::NotFound => None,395 CacheValue::Pending => throw!(InfiniteRecursionDetected),396 CacheValue::Errored(e) => return Err(e.clone()),397 });398 }399 self.0400 .value_cache401 .borrow_mut()402 .insert(cache_key.clone(), CacheValue::Pending);403 let value = self404 .get_raw(key, self.0.this.clone().unwrap_or_else(|| self.clone()))405 .map_err(|e| {406 self.0407 .value_cache408 .borrow_mut()409 .insert(cache_key.clone(), CacheValue::Errored(e.clone()));410 e411 })?;412 self.0.value_cache.borrow_mut().insert(413 cache_key,414 value415 .as_ref()416 .map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),417 );418 Ok(value)419 }420 pub fn get_for(&self, key: IStr, this: Self) -> Result<Option<Val>> {421 self.run_assertions()?;422 let cache_key = (key.clone(), Some(this.clone().downgrade()));423 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {424 return Ok(match v {425 CacheValue::Cached(v) => Some(v.clone()),426 CacheValue::NotFound => None,427 CacheValue::Pending => throw!(InfiniteRecursionDetected),428 CacheValue::Errored(e) => return Err(e.clone()),429 });430 }431 self.0432 .value_cache433 .borrow_mut()434 .insert(cache_key.clone(), CacheValue::Pending);435 let value = self.get_raw(key, this).map_err(|e| {436 self.0437 .value_cache438 .borrow_mut()439 .insert(cache_key.clone(), CacheValue::Errored(e.clone()));440 e441 })?;442 self.0.value_cache.borrow_mut().insert(443 cache_key,444 value445 .as_ref()446 .map_or(CacheValue::NotFound, |v| CacheValue::Cached(v.clone())),447 );448 Ok(value)449 }450451 fn get_raw(&self, key: IStr, real_this: Self) -> Result<Option<Val>> {452 match (self.0.this_entries.get(&key), &self.0.sup) {453 (Some(k), None) => Ok(Some(self.evaluate_this(k, real_this)?)),454 (Some(k), Some(super_obj)) => {455 let our = self.evaluate_this(k, real_this.clone())?;456 if k.add {457 super_obj458 .get_raw(key, real_this)?459 .map_or(Ok(Some(our.clone())), |v| {460 Ok(Some(evaluate_add_op(&v, &our)?))461 })462 } else {463 Ok(Some(our))464 }465 }466 (None, Some(super_obj)) => super_obj.get_raw(key, real_this),467 (None, None) => Ok(None),468 }469 }470 fn evaluate_this(&self, v: &ObjMember, real_this: Self) -> Result<Val> {471 v.invoke.evaluate(self.0.sup.clone(), Some(real_this))472 }473474 fn run_assertions_raw(&self, real_this: &Self) -> Result<()> {475 if self.0.assertions.is_empty() {476 if let Some(super_obj) = &self.0.sup {477 super_obj.run_assertions_raw(real_this)?;478 }479 return Ok(());480 }481 if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {482 for assertion in self.0.assertions.iter() {483 if let Err(e) = assertion.run(self.0.sup.clone(), Some(real_this.clone())) {484 self.0.assertions_ran.borrow_mut().remove(real_this);485 return Err(e);486 }487 }488 if let Some(super_obj) = &self.0.sup {489 super_obj.run_assertions_raw(real_this)?;490 }491 }492 Ok(())493 }494 pub fn run_assertions(&self) -> Result<()> {495 self.run_assertions_raw(self)496 }497498 pub fn ptr_eq(a: &Self, b: &Self) -> bool {499 Cc::ptr_eq(&a.0, &b.0)500 }501 pub fn downgrade(self) -> WeakObjValue {502 WeakObjValue(self.0.downgrade())503 }504}505506impl PartialEq for ObjValue {507 fn eq(&self, other: &Self) -> bool {508 Cc::ptr_eq(&self.0, &other.0)509 }510}511512impl Eq for ObjValue {}513impl Hash for ObjValue {514 fn hash<H: Hasher>(&self, hasher: &mut H) {515 hasher.write_usize(addr_of!(*self.0) as usize);516 }517}518519#[allow(clippy::module_name_repetitions)]520pub struct ObjValueBuilder {521 sup: Option<ObjValue>,522 map: GcHashMap<IStr, ObjMember>,523 assertions: Vec<TraceBox<dyn ObjectAssertion>>,524 next_field_index: FieldIndex,525}526impl ObjValueBuilder {527 pub fn new() -> Self {528 Self::with_capacity(0)529 }530 pub fn with_capacity(capacity: usize) -> Self {531 Self {532 sup: None,533 map: GcHashMap::with_capacity(capacity),534 assertions: Vec::new(),535 next_field_index: FieldIndex::default(),536 }537 }538 pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {539 self.assertions.reserve_exact(capacity);540 self541 }542 pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {543 self.sup = Some(super_obj);544 self545 }546547 pub fn assert(&mut self, assertion: impl ObjectAssertion + 'static) -> &mut Self {548 self.assertions.push(tb!(assertion));549 self550 }551 pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder<'_>> {552 let field_index = self.next_field_index;553 self.next_field_index = self.next_field_index.next();554 ObjMemberBuilder::new(ValueBuilder(self), name, field_index)555 }556557 pub fn build(self) -> ObjValue {558 ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))559 }560}561impl Default for ObjValueBuilder {562 fn default() -> Self {563 Self::with_capacity(0)564 }565}566567#[allow(clippy::module_name_repetitions)]568#[must_use = "value not added unless binding() was called"]569pub struct ObjMemberBuilder<Kind> {570 kind: Kind,571 name: IStr,572 add: bool,573 visibility: Visibility,574 original_index: FieldIndex,575 location: Option<ExprLocation>,576}577578#[allow(clippy::missing_const_for_fn)]579impl<Kind> ObjMemberBuilder<Kind> {580 pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {581 Self {582 kind,583 name,584 original_index,585 add: false,586 visibility: Visibility::Normal,587 location: None,588 }589 }590591 pub const fn with_add(mut self, add: bool) -> Self {592 self.add = add;593 self594 }595 pub fn add(self) -> Self {596 self.with_add(true)597 }598 pub fn with_visibility(mut self, visibility: Visibility) -> Self {599 self.visibility = visibility;600 self601 }602 pub fn hide(self) -> Self {603 self.with_visibility(Visibility::Hidden)604 }605 pub fn with_location(mut self, location: ExprLocation) -> Self {606 self.location = Some(location);607 self608 }609 fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {610 (611 self.kind,612 self.name,613 ObjMember {614 add: self.add,615 visibility: self.visibility,616 original_index: self.original_index,617 invoke: binding,618 location: self.location,619 },620 )621 }622}623624pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);625impl ObjMemberBuilder<ValueBuilder<'_>> {626 627 pub fn value_unchecked(self, value: Val) {628 let (receiver, name, member) =629 self.build_member(MaybeUnbound::Bound(Thunk::evaluated(value)));630 let entry = receiver.0.map.entry(name);631 entry.insert(member);632 }633634 pub fn value(self, value: Val) -> Result<()> {635 self.thunk(Thunk::evaluated(value))636 }637 pub fn thunk(self, value: Thunk<Val>) -> Result<()> {638 self.binding(MaybeUnbound::Bound(value))639 }640 pub fn bindable(self, bindable: impl Unbound<Bound = Val>) -> Result<()> {641 self.binding(MaybeUnbound::Unbound(Cc::new(tb!(bindable))))642 }643 pub fn binding(self, binding: MaybeUnbound) -> Result<()> {644 let (receiver, name, member) = self.build_member(binding);645 let location = member.location.clone();646 let old = receiver.0.map.insert(name.clone(), member);647 if old.is_some() {648 State::push(649 CallLocation(location.as_ref()),650 || format!("field <{}> initializtion", name.clone()),651 || throw!(DuplicateFieldName(name.clone())),652 )?;653 }654 Ok(())655 }656}657658pub struct ExtendBuilder<'v>(&'v mut ObjValue);659impl ObjMemberBuilder<ExtendBuilder<'_>> {660 pub fn value(self, value: Val) {661 self.binding(MaybeUnbound::Bound(Thunk::evaluated(value)));662 }663 pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Val>>) {664 self.binding(MaybeUnbound::Unbound(Cc::new(bindable)));665 }666 pub fn binding(self, binding: MaybeUnbound) {667 let (receiver, name, member) = self.build_member(binding);668 let new = receiver.0.clone();669 *receiver.0 = new.extend_with_raw_member(name, member);670 }671}