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

1use std::{2	any::Any,3	cell::{Cell, RefCell},4	clone::Clone,5	cmp::Reverse,6	collections::hash_map::Entry,7	fmt::{self, Debug},8	hash::{Hash, Hasher},9	num::Saturating,10	ops::ControlFlow,11};1213use educe::Educe;14use im_rc::{Vector, vector};15use jrsonnet_gcmodule::{Acyclic, Cc, Trace, Weak, cc_dyn};16use jrsonnet_interner::IStr;17use jrsonnet_ir::Span;18use rustc_hash::{FxHashMap, FxHashSet};1920mod oop;2122pub use jrsonnet_ir::Visibility;23pub use oop::ObjValueBuilder;2425use crate::{26	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,27	arr::{PickObjectKeyValues, PickObjectValues},28	bail,29	error::{ErrorKind::*, suggest_object_fields},30	evaluate::operator::evaluate_add_op,31	identity_hash,32	val::{ArrValue, ThunkValue},33};3435#[cfg(not(feature = "exp-preserve-order"))]36pub mod ordering {37	#![allow(38		// This module works as stub for preserve-order feature39		clippy::unused_self,40	)]4142	use jrsonnet_gcmodule::Trace;4344	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]45	pub struct FieldIndex(());46	impl FieldIndex {47		pub fn absolute(_v: u32) -> Self {48			Self(())49		}50		#[must_use]51		pub const fn next(self) -> Self {52			Self(())53		}54	}5556	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]57	pub struct SuperDepth(());58	impl SuperDepth {59		pub(super) fn deepen(self) {}60	}61}6263#[cfg(feature = "exp-preserve-order")]64pub mod ordering {65	use jrsonnet_gcmodule::Trace;6667	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]68	pub struct FieldIndex(u32);69	impl FieldIndex {70		pub fn absolute(v: u32) -> Self {71			Self(v)72		}73		#[must_use]74		pub fn next(self) -> Self {75			Self(self.0 + 1)76		}77	}7879	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]80	pub struct SuperDepth(u32);81	impl SuperDepth {82		pub(super) fn deepen(&mut self) {83			self.0 += 1;84		}85	}86}8788use ordering::{FieldIndex, SuperDepth};8990#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]91pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);92impl FieldSortKey {93	pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {94		Self(Reverse(depth), index)95	}96}9798// 0 - add99//  12 - visibility100#[derive(Clone, Copy)]101pub struct ObjFieldFlags(u8);102impl ObjFieldFlags {103	fn new(add: bool, visibility: Visibility) -> Self {104		let mut v = 0;105		if add {106			v |= 1;107		}108		v |= match visibility {109			Visibility::Normal => 0b000,110			Visibility::Hidden => 0b010,111			Visibility::Unhide => 0b100,112		};113		Self(v)114	}115	pub fn add(&self) -> bool {116		self.0 & 1 != 0117	}118	pub fn visibility(&self) -> Visibility {119		match (self.0 & 0b110) >> 1 {120			0b00 => Visibility::Normal,121			0b01 => Visibility::Hidden,122			0b10 => Visibility::Unhide,123			_ => unreachable!(),124		}125	}126}127impl Debug for ObjFieldFlags {128	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {129		f.debug_struct("ObjFieldFlags")130			.field("add", &self.add())131			.field("visibility", &self.visibility())132			.finish()133	}134}135136#[allow(clippy::module_name_repetitions)]137#[derive(Debug, Trace)]138pub struct ObjMember {139	#[trace(skip)]140	flags: ObjFieldFlags,141	original_index: FieldIndex,142	pub invoke: MaybeUnbound,143	pub location: Option<Span>,144}145146cc_dyn!(CcObjectAssertion, ObjectAssertion);147pub trait ObjectAssertion: Trace {148	fn run(&self, sup_this: SupThis) -> Result<()>;149}150151// Field => This152153#[derive(Trace, Debug)]154enum CacheValue {155	Cached(Result<Option<Val>>),156	Pending,157}158159pub type EnumFieldsHandler<'a> =160	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;161162#[derive(Debug)]163pub enum EnumFields {164	Normal(Visibility),165	Omit(Skip),166}167168#[derive(Trace, Clone)]169pub enum GetFor {170	// Return value171	Final(Val),172	// Continue iterating over cores, add current value to sum stack173	SuperPlus(Val),174	// Ignore the field value, stop at this layer instead175	Omit(#[trace(skip)] Skip),176	NotFound,177}178179#[derive(Acyclic, Clone)]180pub enum FieldVisibility {181	Found(Visibility),182	Omit(Skip),183	NotFound,184}185186#[derive(Acyclic, Clone)]187pub enum HasFieldIncludeHidden {188	Exists,189	NotFound,190	Omit(Skip),191}192193type Skip = Saturating<usize>;194195pub trait ObjectCore: Trace + Any + Debug {196	// If callback returns false, iteration stops, and this call returns false.197	fn enum_fields_core(198		&self,199		super_depth: &mut SuperDepth,200		handler: &mut EnumFieldsHandler<'_>,201	) -> bool;202203	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;204205	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;206	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;207208	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;209}210211#[derive(Clone, Trace)]212pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);213impl Debug for WeakObjValue {214	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {215		f.debug_tuple("WeakObjValue").finish()216	}217}218219impl PartialEq for WeakObjValue {220	fn eq(&self, other: &Self) -> bool {221		Weak::ptr_eq(&self.0, &other.0)222	}223}224225impl Eq for WeakObjValue {}226impl Hash for WeakObjValue {227	fn hash<H: Hasher>(&self, hasher: &mut H) {228		// Safety: usize is POD229		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };230		hasher.write_usize(addr);231	}232}233234cc_dyn!(235	#[derive(Clone, Debug)]236	CcObjectCore, ObjectCore,237	pub fn new() {...}238);239240#[derive(Trace, Educe)]241#[educe(Debug)]242struct ObjValueInner {243	cores: Vector<CcObjectCore>,244	assertions_ran: Cell<bool>,245	has_assertions: bool,246	value_cache: RefCell<FxHashMap<(IStr, CoreIdx), CacheValue>>,247}248249thread_local! {250	static RUNNING_ASSERTIONS: RefCell<FxHashSet<ObjValue>> = RefCell::default();251}252fn is_asserting(obj: &ObjValue) -> bool {253	RUNNING_ASSERTIONS.with_borrow(|v| v.contains(obj))254}255/// Returns false if already asserting256fn start_asserting(obj: &ObjValue) -> bool {257	RUNNING_ASSERTIONS.with_borrow_mut(|v| v.insert(obj.clone()))258}259fn finish_asserting(obj: &ObjValue) {260	RUNNING_ASSERTIONS.with_borrow_mut(|v| {261		let r = v.remove(obj);262		debug_assert!(263			r,264			"finish_asserting was called before start_asserting or twice"265		);266	});267}268269thread_local! {270	static EMPTY_OBJ: ObjValue = ObjValue(Cc::new(ObjValueInner {271		cores: vector![],272		assertions_ran: Cell::new(true),273		has_assertions: false,274		value_cache: RefCell::default(),275	}))276}277278#[allow(clippy::module_name_repetitions)]279#[derive(Clone, Trace, Debug, Educe)]280#[educe(PartialEq, Hash, Eq)]281pub struct ObjValue(282	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,283);284285impl ObjValue {286	pub fn empty() -> Self {287		EMPTY_OBJ.with(Clone::clone)288	}289	pub fn is_empty(&self) -> bool {290		self.0.cores.is_empty() || self.len() == 0291	}292}293294#[derive(Trace, Debug)]295pub(crate) struct StandaloneSuperCore {296	sup: CoreIdx,297	this: ObjValue,298}299impl ObjectCore for StandaloneSuperCore {300	fn enum_fields_core(301		&self,302		super_depth: &mut SuperDepth,303		handler: &mut EnumFieldsHandler<'_>,304	) -> bool {305		self.this.enum_fields_idx(super_depth, handler, self.sup)306	}307308	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {309		if self.this.has_field_include_hidden_idx(name, self.sup) {310			HasFieldIncludeHidden::Exists311		} else {312			HasFieldIncludeHidden::NotFound313		}314	}315316	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {317		if omit_only {318			return Ok(GetFor::NotFound);319		}320		let v = self.this.get_idx(key, self.sup)?;321		Ok(v.map_or(GetFor::NotFound, GetFor::Final))322	}323324	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {325		self.this326			.field_visibility_idx(field, self.sup)327			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)328	}329330	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {331		self.this.run_assertions()332	}333}334335#[derive(Debug, Acyclic)]336struct OmitFieldsCore {337	omit: FxHashSet<IStr>,338	prev_layers: usize,339}340impl ObjectCore for OmitFieldsCore {341	fn enum_fields_core(342		&self,343		super_depth: &mut SuperDepth,344		handler: &mut EnumFieldsHandler<'_>,345	) -> bool {346		let mut fi = FieldIndex::default();347		for f in &self.omit {348			if handler(349				*super_depth,350				fi,351				f.clone(),352				EnumFields::Omit(Saturating(self.prev_layers)),353			) == ControlFlow::Break(())354			{355				return false;356			}357			fi = fi.next();358		}359		true360	}361362	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {363		if self.omit.contains(&name) {364			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));365		}366		HasFieldIncludeHidden::NotFound367	}368369	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {370		if self.omit.contains(&key) {371			return Ok(GetFor::Omit(Saturating(self.prev_layers)));372		}373		Ok(GetFor::NotFound)374	}375376	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {377		if self.omit.contains(&field) {378			return FieldVisibility::Omit(Saturating(self.prev_layers));379		}380		FieldVisibility::NotFound381	}382383	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {384		Ok(())385	}386}387388#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]389struct CoreIdx {390	idx: usize,391}392impl CoreIdx {393	fn super_exists(self) -> bool {394		self.idx != 0395	}396}397#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]398pub struct SupThis {399	sup: CoreIdx,400	this: ObjValue,401}402impl SupThis {403	/// Create a `SupThis` for a freshly constructed object (no super).404	pub fn new(this: ObjValue) -> Self {405		Self {406			sup: CoreIdx {407				idx: this.0.cores.len(),408			},409			this,410		}411	}412	pub fn has_super(&self) -> bool {413		self.sup.super_exists()414	}415	/// Implementation of `"field" in super` operation,416	/// works faster than standalone super path.417	///418	/// In case of no `super` existence, returns false.419	pub fn field_in_super(&self, field: IStr) -> bool {420		self.this.has_field_include_hidden_idx(field, self.sup)421	}422	/// Implementation of `super.field` operation,423	/// works faster than standalone super path.424	///425	/// In case of no `super` existence, returns `NoSuperFound`426	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {427		if !self.sup.super_exists() {428			bail!(NoSuperFound);429		}430		self.this.get_idx(field, self.sup)431	}432	/// `super` with `self` overriden for top-level lookups.433	/// Exists when super appears outside of `super.field`/`"field" in super` expressions434	/// Exclusive to jrsonnet.435	///436	/// Might return `NoSuperFound` error.437	pub fn standalone_super(&self) -> Result<ObjValue> {438		if !self.sup.super_exists() {439			bail!(NoSuperFound)440		}441		let mut out = ObjValue::builder();442		out.extend_with_core(StandaloneSuperCore {443			sup: self.sup,444			this: self.this.clone(),445		});446		Ok(out.build())447	}448	pub fn this(&self) -> &ObjValue {449		&self.this450	}451	pub fn downgrade(self) -> WeakSupThis {452		WeakSupThis {453			sup: self.sup,454			this: self.this.downgrade(),455		}456	}457}458#[derive(Trace, PartialEq, Eq, Hash, Debug)]459pub struct WeakSupThis {460	sup: CoreIdx,461	this: WeakObjValue,462}463464impl ObjValue {465	pub fn builder() -> ObjValueBuilder {466		ObjValueBuilder::new()467	}468	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {469		ObjValueBuilder::with_capacity(capacity)470	}471	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {472		let mut out = ObjValueBuilder::with_capacity(1);473		out.with_super(self);474		let mut member = out.field(key);475		if value.flags.add() {476			member = member.add();477		}478		if let Some(loc) = value.location {479			member = member.with_location(loc);480		}481		let _ = member482			.with_visibility(value.flags.visibility())483			.binding(value.invoke);484		out.build()485	}486	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {487		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())488	}489490	pub fn extend(&mut self) -> ObjValueBuilder {491		let mut out = ObjValueBuilder::new();492		out.with_super(self.clone());493		out494	}495496	#[must_use]497	pub fn extend_from(&self, sup: Self) -> Self {498		let cores = sup.0.cores.clone() + self.0.cores.clone();499		let has_assertions = sup.0.has_assertions || self.0.has_assertions;500		ObjValue(Cc::new(ObjValueInner {501			cores,502			value_cache: RefCell::default(),503			assertions_ran: Cell::new(!has_assertions),504			has_assertions,505		}))506	}507	// #[must_use]508	// pub fn with_this(&self, this: Self) -> Self {509	// 	self.0.with_this(self.clone(), this)510	// }511	/// Returns amount of visible object fields512	/// If object only contains hidden fields - may return zero.513	pub fn len(&self) -> u32 {514		self.fields_visibility()515			.values()516			.filter(|d| d.visible())517			.count() as u32518	}519	/// For each field, calls callback.520	/// If callback returns false - ends iteration prematurely.521	///522	/// Returns false if ended prematurely523	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {524		let mut super_depth = SuperDepth::default();525		self.enum_fields_idx(526			&mut super_depth,527			handler,528			CoreIdx {529				idx: self.0.cores.len(),530			},531		)532	}533534	fn iter_cores(&self, idx: CoreIdx) -> impl Iterator<Item = &CcObjectCore> {535		self.0.cores.iter().take(idx.idx).rev()536	}537	fn iter_cores_enumerate(&self, idx: CoreIdx) -> impl Iterator<Item = (CoreIdx, &CcObjectCore)> {538		self.0539			.cores540			.iter()541			.take(idx.idx)542			.enumerate()543			.rev()544			.map(|(idx, o)| (CoreIdx { idx }, o))545	}546547	fn enum_fields_idx(548		&self,549		super_depth: &mut SuperDepth,550		handler: &mut EnumFieldsHandler<'_>,551		idx: CoreIdx,552	) -> bool {553		for core in self.iter_cores(idx) {554			if !core.0.enum_fields_core(super_depth, handler) {555				return false;556			}557			super_depth.deepen();558		}559		true560	}561562	pub fn has_field_include_hidden(&self, name: IStr) -> bool {563		self.has_field_include_hidden_idx(564			name,565			CoreIdx {566				idx: self.0.cores.len(),567			},568		)569	}570	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {571		let mut skip = Saturating(0usize);572		for ele in self.iter_cores(core) {573			match ele.0.has_field_include_hidden_core(name.clone()) {574				HasFieldIncludeHidden::Exists => {575					if skip.0 == 0 {576						return true;577					}578				}579				HasFieldIncludeHidden::Omit(new_skip) => {580					// +1 including this core581					skip = skip.max(new_skip + Saturating(1));582				}583				HasFieldIncludeHidden::NotFound => {}584			}585			skip -= 1;586		}587		false588	}589	pub fn has_field(&self, name: IStr) -> bool {590		match self.field_visibility(name) {591			Some(Visibility::Unhide | Visibility::Normal) => true,592			Some(Visibility::Hidden) | None => false,593		}594	}595	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {596		if include_hidden {597			self.has_field_include_hidden(name)598		} else {599			self.has_field(name)600		}601	}602	pub fn get(&self, key: IStr) -> Result<Option<Val>> {603		self.get_idx(604			key,605			CoreIdx {606				idx: self.0.cores.len(),607			},608		)609	}610611	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {612		let cache_key = (key.clone(), core);613		{614			let mut cache = self.0.value_cache.borrow_mut();615			// entry_ref candidate?616			match cache.entry(cache_key.clone()) {617				Entry::Occupied(v) => match v.get() {618					CacheValue::Cached(v) => return v.clone(),619					CacheValue::Pending => {620						if !is_asserting(self) {621							bail!(InfiniteRecursionDetected);622						}623					}624				},625				Entry::Vacant(v) => {626					v.insert(CacheValue::Pending);627				}628			};629		}630		let result = self.get_idx_uncached(key, core);631		{632			let mut cache = self.0.value_cache.borrow_mut();633			cache.insert(cache_key, CacheValue::Cached(result.clone()));634		}635		result636	}637	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {638		self.run_assertions()?;639		let mut first_add = None;640		let mut add_stack: Vec<Val> = Vec::new();641		let mut skip = Saturating(0);642		for (sup, core) in self.iter_cores_enumerate(core) {643			let sup_this = SupThis {644				sup,645				this: self.clone(),646			};647			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {648				GetFor::Final(val) if first_add.is_none() => {649					if skip.0 == 0 {650						return Ok(Some(val));651					}652				}653				GetFor::Final(val) => {654					if skip.0 == 0 {655						add_stack.push(val);656						break;657					}658				}659				GetFor::SuperPlus(val) => {660					if skip.0 == 0 {661						if first_add.is_none() {662							first_add = Some(val);663						} else {664							add_stack.push(val);665						}666					}667				}668				GetFor::Omit(new_skip) => {669					skip = skip.max(new_skip + Saturating(1));670				}671				GetFor::NotFound => {}672			}673			skip -= 1;674		}675		let Some(first) = first_add else {676			if add_stack.is_empty() {677				return Ok(None);678			}679			return Ok(Some(add_stack.pop().expect("single element on stack")));680		};681		if add_stack.is_empty() {682			return Ok(Some(first));683		}684		add_stack.insert(0, first);685		let mut values = add_stack.into_iter().rev();686		let init = values.next().expect("at least 2 elements");687688		values689			.try_fold(init, |a, b| evaluate_add_op(&a, &b))690			.map(Some)691	}692693	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {694		let Some(value) = self.get(key.clone())? else {695			let suggestions = suggest_object_fields(self, key.clone());696			bail!(NoSuchField(key, suggestions))697		};698		Ok(value)699	}700701	fn field_visibility(&self, field: IStr) -> Option<Visibility> {702		self.field_visibility_idx(703			field,704			CoreIdx {705				idx: self.0.cores.len(),706			},707		)708	}709	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {710		let mut exists = false;711		let mut skip = Saturating(0usize);712		for ele in self.iter_cores(core) {713			let vis = ele.0.field_visibility_core(field.clone());714			match vis {715				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {716					if skip.0 == 0 {717						return Some(vis);718					}719				}720				FieldVisibility::Found(Visibility::Normal) => {721					if skip.0 == 0 {722						exists = true;723					}724				}725				FieldVisibility::NotFound => {}726				FieldVisibility::Omit(new_skip) => {727					// +1 including this core728					skip = skip.max(new_skip + Saturating(1));729				}730			}731			skip -= 1;732		}733		exists.then_some(Visibility::Normal)734	}735736	pub fn run_assertions(&self) -> Result<()> {737		if self.0.assertions_ran.get() {738			return Ok(());739		}740		if !start_asserting(self) {741			return Ok(());742		}743		for (idx, ele) in self.0.cores.iter().enumerate() {744			let sup_this = SupThis {745				sup: CoreIdx { idx },746				this: self.clone(),747			};748			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {749				finish_asserting(self);750			})?;751		}752		finish_asserting(self);753		self.0.assertions_ran.set(true);754		Ok(())755	}756757	pub fn iter(758		&self,759		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,760	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {761		let fields = self.fields(762			#[cfg(feature = "exp-preserve-order")]763			preserve_order,764		);765		fields.into_iter().map(|field| {766			(767				field.clone(),768				self.get(field)769					.map(|opt| opt.expect("iterating over keys, field exists")),770			)771		})772	}773	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {774		#[derive(Trace)]775		struct ObjFieldThunk {776			obj: ObjValue,777			key: IStr,778		}779		impl ThunkValue for ObjFieldThunk {780			type Output = Val;781782			fn get(&self) -> Result<Self::Output> {783				self.obj784					.get(self.key.clone())785					.transpose()786					.expect("field existence checked")787			}788		}789790		if !self.has_field_ex(key.clone(), true) {791			return None;792		}793794		Some(Thunk::new(ObjFieldThunk {795			obj: self.clone(),796			key,797		}))798	}799	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {800		#[derive(Trace)]801		struct ObjFieldThunk {802			obj: ObjValue,803			key: IStr,804		}805		impl ThunkValue for ObjFieldThunk {806			type Output = Val;807808			fn get(&self) -> Result<Self::Output> {809				self.obj.get_or_bail(self.key.clone())810			}811		}812813		Thunk::new(ObjFieldThunk {814			obj: self.clone(),815			key,816		})817	}818819	#[allow(dead_code, reason = "used in object ...rest destructuring")]820	pub(crate) fn as_standalone(&self) -> StandaloneSuperCore {821		StandaloneSuperCore {822			sup: CoreIdx {823				idx: self.0.cores.len(),824			},825			this: self.clone(),826		}827	}828	pub fn ptr_eq(a: &Self, b: &Self) -> bool {829		Cc::ptr_eq(&a.0, &b.0)830	}831	pub fn downgrade(self) -> WeakObjValue {832		WeakObjValue(self.0.downgrade())833	}834}835836#[derive(Debug)]837struct FieldVisibilityData {838	omitted_until: Saturating<usize>,839	exists_visible: Option<Visibility>,840	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]841	key: FieldSortKey,842}843impl FieldVisibilityData {844	fn visible(&self) -> bool {845		self.exists_visible846			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")847			.is_visible()848	}849	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]850	fn sort_key(&self) -> FieldSortKey {851		self.key852	}853}854855impl ObjValue {856	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {857		let mut out = FxHashMap::default();858859		let mut super_depth = SuperDepth::default();860		let mut omit_index = Saturating(0);861		for core in self.0.cores.iter().rev() {862			core.0863				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {864					let entry = out.entry(name);865					let data = entry.or_insert_with(|| FieldVisibilityData {866						exists_visible: None,867						key: FieldSortKey::new(depth, index),868						omitted_until: omit_index,869					});870					match visibility {871						EnumFields::Omit(new_skip) => {872							// +1 including this core873							data.omitted_until = data874								.omitted_until875								.max(omit_index + new_skip + Saturating(1));876						}877						EnumFields::Normal(Visibility::Normal) => {878							if data.omitted_until <= omit_index && data.exists_visible.is_none() {879								data.exists_visible = Some(Visibility::Normal);880							}881						}882						EnumFields::Normal(Visibility::Hidden) => {883							if data.omitted_until <= omit_index {884								data.exists_visible = Some(match data.exists_visible {885									// We're iterating in reverse, later unhide is preserved886									Some(Visibility::Unhide) => Visibility::Unhide,887									_ => Visibility::Hidden,888								});889							}890						}891						EnumFields::Normal(Visibility::Unhide) => {892							if data.omitted_until <= omit_index {893								data.exists_visible = Some(match data.exists_visible {894									// We're iterating in reverse, later hide is preserved895									Some(Visibility::Hidden) => Visibility::Hidden,896									_ => Visibility::Unhide,897								});898							}899						}900					}901					ControlFlow::Continue(())902				});903904			super_depth.deepen();905			omit_index += 1;906		}907908		out.retain(|_, v| v.exists_visible.is_some());909910		out911	}912	pub fn fields_ex(913		&self,914		include_hidden: bool,915		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,916	) -> Vec<IStr> {917		#[cfg(feature = "exp-preserve-order")]918		if preserve_order {919			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self920				.fields_visibility()921				.into_iter()922				.filter(|(_, d)| include_hidden || d.visible())923				.enumerate()924				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))925				.unzip();926			keys.sort_unstable_by_key(|v| v.0);927			// Reorder in-place by resulting indexes928			for i in 0..fields.len() {929				let x = fields[i].clone();930				let mut j = i;931				loop {932					let k = keys[j].1;933					keys[j].1 = j;934					if k == i {935						break;936					}937					fields[j] = fields[k].clone();938					j = k;939				}940				fields[j] = x;941			}942			return fields;943		}944945		let mut fields: Vec<_> = self946			.fields_visibility()947			.into_iter()948			.filter(|(_, d)| include_hidden || d.visible())949			.map(|(k, _)| k)950			.collect();951		fields.sort_unstable();952		fields953	}954	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {955		self.fields_ex(956			false,957			#[cfg(feature = "exp-preserve-order")]958			preserve_order,959		)960	}961	pub fn values_ex(962		&self,963		include_hidden: bool,964		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,965	) -> ArrValue {966		ArrValue::new(PickObjectValues::new(967			self.clone(),968			self.fields_ex(969				include_hidden,970				#[cfg(feature = "exp-preserve-order")]971				preserve_order,972			),973		))974	}975	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {976		self.values_ex(977			false,978			#[cfg(feature = "exp-preserve-order")]979			preserve_order,980		)981	}982	pub fn key_values_ex(983		&self,984		include_hidden: bool,985		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,986	) -> ArrValue {987		ArrValue::new(PickObjectKeyValues::new(988			self.clone(),989			self.fields_ex(990				include_hidden,991				#[cfg(feature = "exp-preserve-order")]992				preserve_order,993			),994		))995	}996	pub fn key_values(997		&self,998		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,999	) -> ArrValue {1000		self.key_values_ex(1001			false,1002			#[cfg(feature = "exp-preserve-order")]1003			preserve_order,1004		)1005	}1006}10071008#[allow(clippy::module_name_repetitions)]1009#[must_use = "value not added unless binding() was called"]1010pub struct ObjMemberBuilder<Kind> {1011	kind: Kind,1012	name: IStr,1013	add: bool,1014	visibility: Visibility,1015	original_index: FieldIndex,1016	location: Option<Span>,1017}10181019#[allow(clippy::missing_const_for_fn)]1020impl<Kind> ObjMemberBuilder<Kind> {1021	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {1022		Self {1023			kind,1024			name,1025			original_index,1026			add: false,1027			visibility: Visibility::Normal,1028			location: None,1029		}1030	}10311032	pub const fn with_add(mut self, add: bool) -> Self {1033		self.add = add;1034		self1035	}1036	pub fn add(self) -> Self {1037		self.with_add(true)1038	}1039	pub fn with_visibility(mut self, visibility: Visibility) -> Self {1040		self.visibility = visibility;1041		self1042	}1043	pub fn hide(self) -> Self {1044		self.with_visibility(Visibility::Hidden)1045	}1046	pub fn with_location(mut self, location: Span) -> Self {1047		self.location = Some(location);1048		self1049	}1050	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1051		(1052			self.kind,1053			self.name,1054			ObjMember {1055				flags: ObjFieldFlags::new(self.add, self.visibility),1056				original_index: self.original_index,1057				invoke: binding,1058				location: self.location,1059			},1060		)1061	}1062}10631064pub struct ExtendBuilder<'v>(&'v mut ObjValue);1065impl ObjMemberBuilder<ExtendBuilder<'_>> {1066	pub fn value(self, value: impl Into<Val>) {1067		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1068	}1069	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1070		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1071	}1072	pub fn binding(self, binding: MaybeUnbound) {1073		let (receiver, name, member) = self.build_member(binding);1074		let new = receiver.0.clone();1075		*receiver.0 = new.extend_with_raw_member(name, member);1076	}1077}