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::*, LocError},15 function::CallLocation,16 gc::{GcHashMap, GcHashSet, TraceBox},17 operator::evaluate_add_op,18 throw, LazyBinding, 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: LazyBinding,104 pub location: Option<ExprLocation>,105}106107pub trait ObjectAssertion: Trace {108 fn run(&self, s: State, super_obj: Option<ObjValue>, this: Option<ObjValue>) -> Result<()>;109}110111112type CacheKey = (IStr, WeakObjValue);113114#[derive(Trace)]115enum CacheValue {116 Cached(Val),117 NotFound,118 Pending,119 Errored(LocError),120}121122#[allow(clippy::module_name_repetitions)]123#[derive(Trace)]124#[trace(tracking(force))]125pub struct ObjValueInternals {126 sup: Option<ObjValue>,127 this: Option<ObjValue>,128129 assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,130 assertions_ran: RefCell<GcHashSet<ObjValue>>,131 this_entries: Cc<GcHashMap<IStr, ObjMember>>,132 value_cache: RefCell<GcHashMap<CacheKey, CacheValue>>,133}134135#[derive(Clone, Trace)]136pub struct WeakObjValue(#[trace(skip)] pub(crate) Weak<ObjValueInternals>);137138impl PartialEq for WeakObjValue {139 fn eq(&self, other: &Self) -> bool {140 Weak::ptr_eq(&self.0, &other.0)141 }142}143144impl Eq for WeakObjValue {}145impl Hash for WeakObjValue {146 fn hash<H: Hasher>(&self, hasher: &mut H) {147 148 let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };149 hasher.write_usize(addr);150 }151}152153#[allow(clippy::module_name_repetitions)]154#[derive(Clone, Trace)]155pub struct ObjValue(pub(crate) Cc<ObjValueInternals>);156impl Debug for ObjValue {157 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {158 if let Some(super_obj) = self.0.sup.as_ref() {159 if f.alternate() {160 write!(f, "{:#?}", super_obj)?;161 } else {162 write!(f, "{:?}", super_obj)?;163 }164 write!(f, " + ")?;165 }166 let mut debug = f.debug_struct("ObjValue");167 for (name, member) in self.0.this_entries.iter() {168 debug.field(name, member);169 }170 debug.finish_non_exhaustive()171 }172}173174impl ObjValue {175 pub fn new(176 sup: Option<Self>,177 this_entries: Cc<GcHashMap<IStr, ObjMember>>,178 assertions: Cc<Vec<TraceBox<dyn ObjectAssertion>>>,179 ) -> Self {180 Self(Cc::new(ObjValueInternals {181 sup,182 this: None,183 assertions,184 assertions_ran: RefCell::new(GcHashSet::new()),185 this_entries,186 value_cache: RefCell::new(GcHashMap::new()),187 }))188 }189 pub fn new_empty() -> Self {190 Self::new(None, Cc::new(GcHashMap::new()), Cc::new(Vec::new()))191 }192 #[must_use]193 pub fn extend_from(&self, sup: Self) -> Self {194 match &self.0.sup {195 None => Self::new(196 Some(sup),197 self.0.this_entries.clone(),198 self.0.assertions.clone(),199 ),200 Some(v) => Self::new(201 Some(v.extend_from(sup)),202 self.0.this_entries.clone(),203 self.0.assertions.clone(),204 ),205 }206 }207 pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {208 let mut new = GcHashMap::with_capacity(1);209 new.insert(key, value);210 Self::new(Some(self), Cc::new(new), Cc::new(Vec::new()))211 }212 pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder> {213 ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())214 }215216 #[must_use]217 pub fn with_this(&self, this: Self) -> Self {218 Self(Cc::new(ObjValueInternals {219 sup: self.0.sup.clone(),220 assertions: self.0.assertions.clone(),221 assertions_ran: RefCell::new(GcHashSet::new()),222 this: Some(this),223 this_entries: self.0.this_entries.clone(),224 value_cache: RefCell::new(GcHashMap::new()),225 }))226 }227228 pub fn len(&self) -> usize {229 self.fields_visibility()230 .into_iter()231 .filter(|(_, (visible, _))| *visible)232 .count()233 }234235 pub fn is_empty(&self) -> bool {236 if !self.0.this_entries.is_empty() {237 return false;238 }239 self.0.sup.as_ref().map_or(true, Self::is_empty)240 }241242 243 pub(crate) fn enum_fields(244 &self,245 depth: SuperDepth,246 handler: &mut impl FnMut(SuperDepth, &IStr, &ObjMember) -> bool,247 ) -> bool {248 if let Some(s) = &self.0.sup {249 if s.enum_fields(depth.deeper(), handler) {250 return true;251 }252 }253 for (name, member) in self.0.this_entries.iter() {254 if handler(depth, name, member) {255 return true;256 }257 }258 false259 }260261 pub fn fields_visibility(&self) -> FxHashMap<IStr, (bool, FieldSortKey)> {262 let mut out = FxHashMap::default();263 self.enum_fields(SuperDepth::default(), &mut |depth, name, member| {264 let new_sort_key = FieldSortKey::new(depth, member.original_index);265 let entry = out.entry(name.clone());266 let (visible, _) = entry.or_insert((true, new_sort_key));267 match member.visibility {268 Visibility::Normal => {}269 Visibility::Hidden => {270 *visible = false;271 }272 Visibility::Unhide => {273 *visible = true;274 }275 };276 false277 });278 out279 }280 pub fn fields_ex(281 &self,282 include_hidden: bool,283 #[cfg(feature = "exp-preserve-order")] preserve_order: bool,284 ) -> Vec<IStr> {285 #[cfg(feature = "exp-preserve-order")]286 if preserve_order {287 let (mut fields, mut keys): (Vec<_>, Vec<_>) = self288 .fields_visibility()289 .into_iter()290 .filter(|(_, (visible, _))| include_hidden || *visible)291 .enumerate()292 .map(|(idx, (k, (_, sk)))| (k, (sk, idx)))293 .unzip();294 keys.sort_unstable_by_key(|v| v.0);295 296 for i in 0..fields.len() {297 let x = fields[i].clone();298 let mut j = i;299 loop {300 let k = keys[j].1;301 keys[j].1 = j;302 if k == i {303 break;304 }305 fields[j] = fields[k].clone();306 j = k307 }308 fields[j] = x;309 }310 return fields;311 }312313 let mut fields: Vec<_> = self314 .fields_visibility()315 .into_iter()316 .filter(|(_, (visible, _))| include_hidden || *visible)317 .map(|(k, _)| k)318 .collect();319 fields.sort_unstable();320 fields321 }322 pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {323 self.fields_ex(324 false,325 #[cfg(feature = "exp-preserve-order")]326 preserve_order,327 )328 }329330 pub fn field_visibility(&self, name: IStr) -> Option<Visibility> {331 if let Some(m) = self.0.this_entries.get(&name) {332 Some(match &m.visibility {333 Visibility::Normal => self334 .0335 .sup336 .as_ref()337 .and_then(|super_obj| super_obj.field_visibility(name))338 .unwrap_or(Visibility::Normal),339 v => *v,340 })341 } else if let Some(super_obj) = &self.0.sup {342 super_obj.field_visibility(name)343 } else {344 None345 }346 }347348 fn has_field_include_hidden(&self, name: IStr) -> bool {349 if self.0.this_entries.contains_key(&name) {350 true351 } else if let Some(super_obj) = &self.0.sup {352 super_obj.has_field_include_hidden(name)353 } else {354 false355 }356 }357358 pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {359 if include_hidden {360 self.has_field_include_hidden(name)361 } else {362 self.has_field(name)363 }364 }365 pub fn has_field(&self, name: IStr) -> bool {366 self.field_visibility(name)367 .map_or(false, |v| v.is_visible())368 }369370 pub fn get(&self, s: State, key: IStr) -> Result<Option<Val>> {371 self.run_assertions(s.clone())?;372 self.get_raw(s, key, self.0.this.clone().unwrap_or_else(|| self.clone()))373 }374375 376377 fn get_raw(&self, s: State, key: IStr, real_this: Self) -> Result<Option<Val>> {378 let cache_key = (key.clone(), WeakObjValue(real_this.0.downgrade()));379380 if let Some(v) = self.0.value_cache.borrow().get(&cache_key) {381 return Ok(match v {382 CacheValue::Cached(v) => Some(v.clone()),383 CacheValue::NotFound => None,384 CacheValue::Pending => throw!(InfiniteRecursionDetected),385 CacheValue::Errored(e) => return Err(e.clone()),386 });387 }388 self.0389 .value_cache390 .borrow_mut()391 .insert(cache_key.clone(), CacheValue::Pending);392 let fill_error = |e: LocError| {393 self.0394 .value_cache395 .borrow_mut()396 .insert(cache_key.clone(), CacheValue::Errored(e.clone()));397 e398 };399 let value = match (self.0.this_entries.get(&key), &self.0.sup) {400 (Some(k), None) => Ok(Some(401 self.evaluate_this(s, k, real_this).map_err(fill_error)?,402 )),403 (Some(k), Some(super_obj)) => {404 let our = self405 .evaluate_this(s.clone(), k, real_this.clone())406 .map_err(fill_error)?;407 if k.add {408 super_obj409 .get_raw(s.clone(), key, real_this)410 .map_err(fill_error)?411 .map_or(Ok(Some(our.clone())), |v| {412 Ok(Some(evaluate_add_op(s.clone(), &v, &our)?))413 })414 } else {415 Ok(Some(our))416 }417 }418 (None, Some(super_obj)) => super_obj.get_raw(s, key, real_this),419 (None, None) => Ok(None),420 }421 .map_err(fill_error)?;422 self.0.value_cache.borrow_mut().insert(423 cache_key,424 match &value {425 Some(v) => CacheValue::Cached(v.clone()),426 None => CacheValue::NotFound,427 },428 );429 Ok(value)430 }431 fn evaluate_this(&self, s: State, v: &ObjMember, real_this: Self) -> Result<Val> {432 v.invoke433 .evaluate(s.clone(), self.0.sup.clone(), Some(real_this))?434 .evaluate(s)435 }436437 fn run_assertions_raw(&self, s: State, real_this: &Self) -> Result<()> {438 if self.0.assertions_ran.borrow_mut().insert(real_this.clone()) {439 for assertion in self.0.assertions.iter() {440 if let Err(e) =441 assertion.run(s.clone(), self.0.sup.clone(), Some(real_this.clone()))442 {443 self.0.assertions_ran.borrow_mut().remove(real_this);444 return Err(e);445 }446 }447 if let Some(super_obj) = &self.0.sup {448 super_obj.run_assertions_raw(s, real_this)?;449 }450 }451 Ok(())452 }453 pub fn run_assertions(&self, s: State) -> Result<()> {454 self.run_assertions_raw(s, self)455 }456457 pub fn ptr_eq(a: &Self, b: &Self) -> bool {458 Cc::ptr_eq(&a.0, &b.0)459 }460 pub fn downgrade(self) -> WeakObjValue {461 WeakObjValue(self.0.downgrade())462 }463}464465impl PartialEq for ObjValue {466 fn eq(&self, other: &Self) -> bool {467 Cc::ptr_eq(&self.0, &other.0)468 }469}470471impl Eq for ObjValue {}472impl Hash for ObjValue {473 fn hash<H: Hasher>(&self, hasher: &mut H) {474 hasher.write_usize(addr_of!(*self.0) as usize);475 }476}477478#[allow(clippy::module_name_repetitions)]479pub struct ObjValueBuilder {480 sup: Option<ObjValue>,481 map: GcHashMap<IStr, ObjMember>,482 assertions: Vec<TraceBox<dyn ObjectAssertion>>,483 next_field_index: FieldIndex,484}485impl ObjValueBuilder {486 pub fn new() -> Self {487 Self::with_capacity(0)488 }489 pub fn with_capacity(capacity: usize) -> Self {490 Self {491 sup: None,492 map: GcHashMap::with_capacity(capacity),493 assertions: Vec::new(),494 next_field_index: FieldIndex::default(),495 }496 }497 pub fn reserve_asserts(&mut self, capacity: usize) -> &mut Self {498 self.assertions.reserve_exact(capacity);499 self500 }501 pub fn with_super(&mut self, super_obj: ObjValue) -> &mut Self {502 self.sup = Some(super_obj);503 self504 }505506 pub fn assert(&mut self, assertion: TraceBox<dyn ObjectAssertion>) -> &mut Self {507 self.assertions.push(assertion);508 self509 }510 pub fn member(&mut self, name: IStr) -> ObjMemberBuilder<ValueBuilder> {511 let field_index = self.next_field_index;512 self.next_field_index = self.next_field_index.next();513 ObjMemberBuilder::new(ValueBuilder(self), name, field_index)514 }515516 pub fn build(self) -> ObjValue {517 ObjValue::new(self.sup, Cc::new(self.map), Cc::new(self.assertions))518 }519}520impl Default for ObjValueBuilder {521 fn default() -> Self {522 Self::with_capacity(0)523 }524}525526#[allow(clippy::module_name_repetitions)]527#[must_use = "value not added unless binding() was called"]528pub struct ObjMemberBuilder<Kind> {529 kind: Kind,530 name: IStr,531 add: bool,532 visibility: Visibility,533 original_index: FieldIndex,534 location: Option<ExprLocation>,535}536537#[allow(clippy::missing_const_for_fn)]538impl<Kind> ObjMemberBuilder<Kind> {539 pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {540 Self {541 kind,542 name,543 original_index,544 add: false,545 visibility: Visibility::Normal,546 location: None,547 }548 }549550 pub const fn with_add(mut self, add: bool) -> Self {551 self.add = add;552 self553 }554 pub fn add(self) -> Self {555 self.with_add(true)556 }557 pub fn with_visibility(mut self, visibility: Visibility) -> Self {558 self.visibility = visibility;559 self560 }561 pub fn hide(self) -> Self {562 self.with_visibility(Visibility::Hidden)563 }564 pub fn with_location(mut self, location: ExprLocation) -> Self {565 self.location = Some(location);566 self567 }568 fn build_member(self, binding: LazyBinding) -> (Kind, IStr, ObjMember) {569 (570 self.kind,571 self.name,572 ObjMember {573 add: self.add,574 visibility: self.visibility,575 original_index: self.original_index,576 invoke: binding,577 location: self.location,578 },579 )580 }581}582583pub struct ValueBuilder<'v>(&'v mut ObjValueBuilder);584impl<'v> ObjMemberBuilder<ValueBuilder<'v>> {585 pub fn value(self, s: State, value: Val) -> Result<()> {586 self.binding(s, LazyBinding::Bound(Thunk::evaluated(value)))587 }588 pub fn bindable(589 self,590 s: State,591 bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>,592 ) -> Result<()> {593 self.binding(s, LazyBinding::Bindable(Cc::new(bindable)))594 }595 pub fn binding(self, s: State, binding: LazyBinding) -> Result<()> {596 let (receiver, name, member) = self.build_member(binding);597 let location = member.location.clone();598 let old = receiver.0.map.insert(name.clone(), member);599 if old.is_some() {600 s.push(601 CallLocation(location.as_ref()),602 || format!("field <{}> initializtion", name.clone()),603 || throw!(DuplicateFieldName(name.clone())),604 )?;605 }606 Ok(())607 }608}609610pub struct ExtendBuilder<'v>(&'v mut ObjValue);611impl<'v> ObjMemberBuilder<ExtendBuilder<'v>> {612 pub fn value(self, value: Val) {613 self.binding(LazyBinding::Bound(Thunk::evaluated(value)));614 }615 pub fn bindable(self, bindable: TraceBox<dyn Unbound<Bound = Thunk<Val>>>) {616 self.binding(LazyBinding::Bindable(Cc::new(bindable)));617 }618 pub fn binding(self, binding: LazyBinding) {619 let (receiver, name, member) = self.build_member(binding);620 let new = receiver.0.clone();621 *receiver.0 = new.extend_with_raw_member(name, member);622 }623}