git.delta.rocks / jrsonnet / refs/commits / 27958b04316f

1use std::{2	any::Any, cell::{Cell, RefCell}, clone::Clone, cmp::Reverse, collections::hash_map::Entry, fmt::{self, Debug}, hash::{Hash, Hasher}, num::Saturating, ops::ControlFlow3};45use educe::Educe;6use jrsonnet_gcmodule::{cc_dyn, Acyclic, Cc, Trace, Weak};7use jrsonnet_interner::IStr;8use jrsonnet_ir::Span;9use rustc_hash::{FxHashMap, FxHashSet};1011mod oop;1213pub use jrsonnet_ir::Visibility;14pub use oop::ObjValueBuilder;1516use crate::{17	arr::{PickObjectKeyValues, PickObjectValues},18	bail,19	error::{suggest_object_fields, ErrorKind::*},20	identity_hash,21	operator::evaluate_add_op,22	val::{ArrValue, ThunkValue},23	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,24};2526#[cfg(not(feature = "exp-preserve-order"))]27pub mod ordering {28	#![allow(29		// This module works as stub for preserve-order feature30		clippy::unused_self,31	)]3233	use jrsonnet_gcmodule::Trace;3435	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]36	pub struct FieldIndex(());37	impl FieldIndex {38		pub fn absolute(_v: u32) -> Self {39			Self(())40		}41		#[must_use]42		pub const fn next(self) -> Self {43			Self(())44		}45	}4647	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]48	pub struct SuperDepth(());49	impl SuperDepth {50		pub(super) fn deepen(self) {}51	}52}5354#[cfg(feature = "exp-preserve-order")]55pub mod ordering {56	use jrsonnet_gcmodule::Trace;5758	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]59	pub struct FieldIndex(u32);60	impl FieldIndex {61		pub fn absolute(v: u32) -> Self {62			Self(v)63		}64		#[must_use]65		pub fn next(self) -> Self {66			Self(self.0 + 1)67		}68	}6970	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]71	pub struct SuperDepth(u32);72	impl SuperDepth {73		pub(super) fn deepen(&mut self) {74			self.0 += 1;75		}76	}77}7879use ordering::{FieldIndex, SuperDepth};8081#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]82pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);83impl FieldSortKey {84	pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {85		Self(Reverse(depth), index)86	}87}8889// 0 - add90//  12 - visibility91#[derive(Clone, Copy)]92pub struct ObjFieldFlags(u8);93impl ObjFieldFlags {94	fn new(add: bool, visibility: Visibility) -> Self {95		let mut v = 0;96		if add {97			v |= 1;98		}99		v |= match visibility {100			Visibility::Normal => 0b000,101			Visibility::Hidden => 0b010,102			Visibility::Unhide => 0b100,103		};104		Self(v)105	}106	pub fn add(&self) -> bool {107		self.0 & 1 != 0108	}109	pub fn visibility(&self) -> Visibility {110		match (self.0 & 0b110) >> 1 {111			0b00 => Visibility::Normal,112			0b01 => Visibility::Hidden,113			0b10 => Visibility::Unhide,114			_ => unreachable!(),115		}116	}117}118impl Debug for ObjFieldFlags {119	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {120		f.debug_struct("ObjFieldFlags")121			.field("add", &self.add())122			.field("visibility", &self.visibility())123			.finish()124	}125}126127#[allow(clippy::module_name_repetitions)]128#[derive(Debug, Trace)]129pub struct ObjMember {130	#[trace(skip)]131	flags: ObjFieldFlags,132	original_index: FieldIndex,133	pub invoke: MaybeUnbound,134	pub location: Option<Span>,135}136137cc_dyn!(CcObjectAssertion, ObjectAssertion);138pub trait ObjectAssertion: Trace {139	fn run(&self, sup_this: SupThis) -> Result<()>;140}141142// Field => This143144#[derive(Trace, Debug)]145enum CacheValue {146	Cached(Result<Option<Val>>),147	Pending,148}149150pub type EnumFieldsHandler<'a> =151	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;152153pub enum EnumFields {154	Normal(Visibility),155	Omit(Skip),156}157158#[derive(Trace, Clone)]159pub enum GetFor {160	// Return value161	Final(Val),162	// Continue iterating over cores, add current value to sum stack163	SuperPlus(Val),164	// Ignore the field value, stop at this layer instead165	Omit(#[trace(skip)] Skip),166	NotFound,167}168169#[derive(Acyclic, Clone)]170pub enum FieldVisibility {171	Found(Visibility),172	Omit(Skip),173	NotFound,174}175176#[derive(Acyclic, Clone)]177pub enum HasFieldIncludeHidden {178	Exists,179	NotFound,180	Omit(Skip),181}182183type Skip = Saturating<usize>;184185pub trait ObjectCore: Trace + Any + Debug {186	// If callback returns false, iteration stops, and this call returns false.187	fn enum_fields_core(188		&self,189		super_depth: &mut SuperDepth,190		handler: &mut EnumFieldsHandler<'_>,191	) -> bool;192193	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;194195	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;196	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;197198	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;199}200201#[derive(Clone, Trace)]202pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);203impl Debug for WeakObjValue {204	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {205		f.debug_tuple("WeakObjValue").finish()206	}207}208209impl PartialEq for WeakObjValue {210	fn eq(&self, other: &Self) -> bool {211		Weak::ptr_eq(&self.0, &other.0)212	}213}214215impl Eq for WeakObjValue {}216impl Hash for WeakObjValue {217	fn hash<H: Hasher>(&self, hasher: &mut H) {218		// Safety: usize is POD219		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };220		hasher.write_usize(addr);221	}222}223224cc_dyn!(225	#[derive(Clone, Debug)]226	CcObjectCore, ObjectCore,227	pub fn new() {...}228);229#[derive(Trace, Educe)]230#[educe(Debug)]231struct ObjValueInner {232	cores: Vec<CcObjectCore>,233	assertions_ran: Cell<bool>,234	#[trace(skip)]235	has_assertions: bool,236	value_cache: RefCell<FxHashMap<(IStr, CoreIdx), CacheValue>>,237}238239thread_local! {240	static RUNNING_ASSERTIONS: RefCell<FxHashSet<ObjValue>> = RefCell::default();241}242fn is_asserting(obj: &ObjValue) -> bool {243	RUNNING_ASSERTIONS.with_borrow(|v| v.contains(obj))244}245/// Returns false if already asserting246fn start_asserting(obj: &ObjValue) -> bool {247	RUNNING_ASSERTIONS.with_borrow_mut(|v| v.insert(obj.clone()))248}249fn finish_asserting(obj: &ObjValue) {250	RUNNING_ASSERTIONS.with_borrow_mut(|v| {251		let r = v.remove(obj);252		debug_assert!(253			r,254			"finish_asserting was called before start_asserting or twice"255		);256	});257}258259thread_local! {260	static EMPTY_OBJ: ObjValue = ObjValue(Cc::new(ObjValueInner {261		cores: vec![],262		assertions_ran: Cell::new(true),263		has_assertions: false,264		value_cache: RefCell::default(),265	}))266}267268#[allow(clippy::module_name_repetitions)]269#[derive(Clone, Trace, Debug, Educe)]270#[educe(PartialEq, Hash, Eq)]271pub struct ObjValue(272	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,273);274275impl ObjValue {276	pub fn empty() -> Self {277		EMPTY_OBJ.with(Clone::clone)278	}279	pub fn is_empty(&self) -> bool {280		self.0.cores.is_empty() || self.len() == 0281	}282}283284#[derive(Trace, Debug)]285struct StandaloneSuperCore {286	sup: CoreIdx,287	this: ObjValue,288}289impl ObjectCore for StandaloneSuperCore {290	fn enum_fields_core(291		&self,292		super_depth: &mut SuperDepth,293		handler: &mut EnumFieldsHandler<'_>,294	) -> bool {295		self.this.enum_fields_idx(super_depth, handler, self.sup)296	}297298	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {299		if self.this.has_field_include_hidden_idx(name, self.sup) {300			HasFieldIncludeHidden::Exists301		} else {302			HasFieldIncludeHidden::NotFound303		}304	}305306	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {307		if omit_only {308			return Ok(GetFor::NotFound);309		}310		let v = self.this.get_idx(key, self.sup)?;311		Ok(v.map_or(GetFor::NotFound, GetFor::Final))312	}313314	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {315		self.this316			.field_visibility_idx(field, self.sup)317			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)318	}319320	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {321		self.this.run_assertions()322	}323}324325#[derive(Debug, Acyclic)]326struct OmitFieldsCore {327	omit: FxHashSet<IStr>,328	prev_layers: usize,329}330impl ObjectCore for OmitFieldsCore {331	fn enum_fields_core(332		&self,333		super_depth: &mut SuperDepth,334		handler: &mut EnumFieldsHandler<'_>,335	) -> bool {336		let mut fi = FieldIndex::default();337		for f in &self.omit {338			if handler(339				*super_depth,340				fi,341				f.clone(),342				EnumFields::Omit(Saturating(self.prev_layers)),343			) == ControlFlow::Break(())344			{345				return false;346			}347			fi = fi.next();348		}349		true350	}351352	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {353		if self.omit.contains(&name) {354			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));355		}356		HasFieldIncludeHidden::NotFound357	}358359	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {360		if self.omit.contains(&key) {361			return Ok(GetFor::Omit(Saturating(self.prev_layers)));362		}363		Ok(GetFor::NotFound)364	}365366	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {367		if self.omit.contains(&field) {368			return FieldVisibility::Omit(Saturating(self.prev_layers));369		}370		FieldVisibility::NotFound371	}372373	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {374		Ok(())375	}376}377378#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]379struct CoreIdx {380	idx: usize,381}382impl CoreIdx {383	fn super_exists(self) -> bool {384		self.idx != 0385	}386}387#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]388pub struct SupThis {389	sup: CoreIdx,390	this: ObjValue,391}392impl SupThis {393	pub fn has_super(&self) -> bool {394		self.sup.super_exists()395	}396	/// Implementation of `"field" in super` operation,397	/// works faster than standalone super path.398	///399	/// In case of no `super` existence, returns false.400	pub fn field_in_super(&self, field: IStr) -> bool {401		self.this.has_field_include_hidden_idx(field, self.sup)402	}403	/// Implementation of `super.field` operation,404	/// works faster than standalone super path.405	///406	/// In case of no `super` existence, returns `NoSuperFound`407	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {408		if !self.sup.super_exists() {409			bail!(NoSuperFound);410		}411		self.this.get_idx(field, self.sup)412	}413	/// `super` with `self` overriden for top-level lookups.414	/// Exists when super appears outside of `super.field`/`"field" in super` expressions415	/// Exclusive to jrsonnet.416	///417	/// Might return `NoSuperFound` error.418	pub fn standalone_super(&self) -> Result<ObjValue> {419		if !self.sup.super_exists() {420			bail!(NoSuperFound)421		}422		let mut out = ObjValue::builder();423		out.reserve_cores(1).extend_with_core(StandaloneSuperCore {424			sup: self.sup,425			this: self.this.clone(),426		});427		Ok(out.build())428	}429	pub fn this(&self) -> &ObjValue {430		&self.this431	}432	pub fn downgrade(self) -> WeakSupThis {433		WeakSupThis {434			sup: self.sup,435			this: self.this.downgrade(),436		}437	}438}439#[derive(Trace, PartialEq, Eq, Hash, Debug)]440pub struct WeakSupThis {441	sup: CoreIdx,442	this: WeakObjValue,443}444445impl ObjValue {446	pub fn builder() -> ObjValueBuilder {447		ObjValueBuilder::new()448	}449	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {450		ObjValueBuilder::with_capacity(capacity)451	}452	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {453		let mut out = ObjValueBuilder::with_capacity(1);454		out.with_super(self);455		let mut member = out.field(key);456		if value.flags.add() {457			member = member.add();458		}459		if let Some(loc) = value.location {460			member = member.with_location(loc);461		}462		let _ = member463			.with_visibility(value.flags.visibility())464			.binding(value.invoke);465		out.build()466	}467	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {468		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())469	}470471	pub fn extend(&mut self) -> ObjValueBuilder {472		let mut out = ObjValueBuilder::new();473		out.with_super(self.clone());474		out475	}476477	#[must_use]478	pub fn extend_from(&self, sup: Self) -> Self {479		let mut cores = Vec::with_capacity(sup.0.cores.len() + self.0.cores.len());480		cores.extend(sup.0.cores.iter().cloned());481		cores.extend(self.0.cores.iter().cloned());482		let has_assertions = sup.0.has_assertions || self.0.has_assertions;483		ObjValue(Cc::new(ObjValueInner {484			cores,485			value_cache: RefCell::default(),486			assertions_ran: Cell::new(!has_assertions),487			has_assertions,488		}))489	}490	// #[must_use]491	// pub fn with_this(&self, this: Self) -> Self {492	// 	self.0.with_this(self.clone(), this)493	// }494	/// Returns amount of visible object fields495	/// If object only contains hidden fields - may return zero.496	pub fn len(&self) -> usize {497		self.fields_visibility()498			.values()499			.filter(|d| d.visible())500			.count()501	}502	/// For each field, calls callback.503	/// If callback returns false - ends iteration prematurely.504	///505	/// Returns false if ended prematurely506	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {507		let mut super_depth = SuperDepth::default();508		self.enum_fields_idx(509			&mut super_depth,510			handler,511			CoreIdx {512				idx: self.0.cores.len(),513			},514		)515	}516	fn enum_fields_idx(517		&self,518		super_depth: &mut SuperDepth,519		handler: &mut EnumFieldsHandler<'_>,520		idx: CoreIdx,521	) -> bool {522		for core in self.0.cores[..idx.idx].iter().rev() {523			if !core.0.enum_fields_core(super_depth, handler) {524				return false;525			}526			super_depth.deepen();527		}528		true529	}530531	pub fn has_field_include_hidden(&self, name: IStr) -> bool {532		self.has_field_include_hidden_idx(533			name,534			CoreIdx {535				idx: self.0.cores.len(),536			},537		)538	}539	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {540		let mut skip = Saturating(0usize);541		for ele in self.0.cores[..core.idx].iter().rev() {542			match ele.0.has_field_include_hidden_core(name.clone()) {543				HasFieldIncludeHidden::Exists => {544					if skip.0 == 0 {545						return true;546					}547				}548				HasFieldIncludeHidden::Omit(new_skip) => {549					// +1 including this core550					skip = skip.max(new_skip + Saturating(1));551				}552				HasFieldIncludeHidden::NotFound => {}553			}554			skip -= 1;555		}556		false557	}558	pub fn has_field(&self, name: IStr) -> bool {559		match self.field_visibility(name) {560			Some(Visibility::Unhide | Visibility::Normal) => true,561			Some(Visibility::Hidden) | None => false,562		}563	}564	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {565		if include_hidden {566			self.has_field_include_hidden(name)567		} else {568			self.has_field(name)569		}570	}571	pub fn get(&self, key: IStr) -> Result<Option<Val>> {572		self.get_idx(573			key,574			CoreIdx {575				idx: self.0.cores.len(),576			},577		)578	}579580	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {581		let cache_key = (key.clone(), core);582		{583			let mut cache = self.0.value_cache.borrow_mut();584			// entry_ref candidate?585			match cache.entry(cache_key.clone()) {586				Entry::Occupied(v) => match v.get() {587					CacheValue::Cached(v) => return v.clone(),588					CacheValue::Pending => {589						if !is_asserting(self) {590							bail!(InfiniteRecursionDetected);591						}592					}593				},594				Entry::Vacant(v) => {595					v.insert(CacheValue::Pending);596				}597			};598		}599		let result = self.get_idx_uncached(key, core);600		{601			let mut cache = self.0.value_cache.borrow_mut();602			cache.insert(cache_key, CacheValue::Cached(result.clone()));603		}604		result605	}606	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {607		self.run_assertions()?;608		let mut first_add = None;609		let mut add_stack: Vec<Val> = Vec::new();610		let mut skip = Saturating(0);611		for (sup, core) in self.0.cores[..core.idx].iter().enumerate().rev() {612			let sup_this = SupThis {613				sup: CoreIdx { idx: sup },614				this: self.clone(),615			};616			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {617				GetFor::Final(val) if first_add.is_none() => {618					if skip.0 == 0 {619						return Ok(Some(val));620					}621				}622				GetFor::Final(val) => {623					if skip.0 == 0 {624						add_stack.push(val);625						break;626					}627				}628				GetFor::SuperPlus(val) => {629					if skip.0 == 0 {630						if first_add.is_none() {631							first_add = Some(val);632						} else {633							add_stack.push(val);634						}635					}636				}637				GetFor::Omit(new_skip) => {638					skip = skip.max(new_skip + Saturating(1));639				}640				GetFor::NotFound => {}641			}642			skip -= 1;643		}644		let Some(first) = first_add else {645			if add_stack.is_empty() {646				return Ok(None);647			}648			return Ok(Some(add_stack.pop().expect("single element on stack")));649		};650		if add_stack.is_empty() {651			return Ok(Some(first));652		}653		add_stack.insert(0, first);654		let mut values = add_stack.into_iter().rev();655		let init = values.next().expect("at least 2 elements");656657		values658			.try_fold(init, |a, b| evaluate_add_op(&a, &b))659			.map(Some)660	}661662	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {663		let Some(value) = self.get(key.clone())? else {664			let suggestions = suggest_object_fields(self, key.clone());665			bail!(NoSuchField(key, suggestions))666		};667		Ok(value)668	}669670	fn field_visibility(&self, field: IStr) -> Option<Visibility> {671		self.field_visibility_idx(672			field,673			CoreIdx {674				idx: self.0.cores.len(),675			},676		)677	}678	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {679		let mut exists = false;680		let mut skip = Saturating(0usize);681		for ele in self.0.cores[..core.idx].iter().rev() {682			let vis = ele.0.field_visibility_core(field.clone());683			match vis {684				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {685					if skip.0 == 0 {686						return Some(vis);687					}688				}689				FieldVisibility::Found(Visibility::Normal) => {690					if skip.0 == 0 {691						exists = true;692					}693				}694				FieldVisibility::NotFound => {}695				FieldVisibility::Omit(new_skip) => {696					// +1 including this core697					skip = skip.max(new_skip + Saturating(1));698				}699			}700			skip -= 1;701		}702		exists.then_some(Visibility::Normal)703	}704705	pub fn run_assertions(&self) -> Result<()> {706		if self.0.assertions_ran.get() {707			return Ok(());708		}709		if !start_asserting(self) {710			return Ok(());711		}712		for (idx, ele) in self.0.cores.iter().enumerate() {713			let sup_this = SupThis {714				sup: CoreIdx { idx },715				this: self.clone(),716			};717			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {718				finish_asserting(self);719			})?;720		}721		finish_asserting(self);722		self.0.assertions_ran.set(true);723		Ok(())724	}725726	pub fn iter(727		&self,728		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,729	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {730		let fields = self.fields(731			#[cfg(feature = "exp-preserve-order")]732			preserve_order,733		);734		fields.into_iter().map(|field| {735			(736				field.clone(),737				self.get(field)738					.map(|opt| opt.expect("iterating over keys, field exists")),739			)740		})741	}742	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {743		#[derive(Trace)]744		struct ObjFieldThunk {745			obj: ObjValue,746			key: IStr,747		}748		impl ThunkValue for ObjFieldThunk {749			type Output = Val;750751			fn get(&self) -> Result<Self::Output> {752				self.obj753					.get(self.key.clone())754					.transpose()755					.expect("field existence checked")756			}757		}758759		if !self.has_field_ex(key.clone(), true) {760			return None;761		}762763		Some(Thunk::new(ObjFieldThunk {764			obj: self.clone(),765			key,766		}))767	}768	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {769		#[derive(Trace)]770		struct ObjFieldThunk {771			obj: ObjValue,772			key: IStr,773		}774		impl ThunkValue for ObjFieldThunk {775			type Output = Val;776777			fn get(&self) -> Result<Self::Output> {778				self.obj.get_or_bail(self.key.clone())779			}780		}781782		Thunk::new(ObjFieldThunk {783			obj: self.clone(),784			key,785		})786	}787	pub fn ptr_eq(a: &Self, b: &Self) -> bool {788		Cc::ptr_eq(&a.0, &b.0)789	}790	pub fn downgrade(self) -> WeakObjValue {791		WeakObjValue(self.0.downgrade())792	}793}794795#[derive(Debug)]796struct FieldVisibilityData {797	omitted_until: Saturating<usize>,798	exists_visible: Option<Visibility>,799	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]800	key: FieldSortKey,801}802impl FieldVisibilityData {803	fn visible(&self) -> bool {804		self.exists_visible805			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")806			.is_visible()807	}808	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]809	fn sort_key(&self) -> FieldSortKey {810		self.key811	}812}813814impl ObjValue {815	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {816		let mut out = FxHashMap::default();817818		let mut super_depth = SuperDepth::default();819		let mut omit_index = Saturating(0);820		for core in self.0.cores.iter().rev() {821			core.0822				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {823					let entry = out.entry(name);824					let data = entry.or_insert_with(|| FieldVisibilityData {825						exists_visible: None,826						key: FieldSortKey::new(depth, index),827						omitted_until: omit_index,828					});829					match visibility {830						EnumFields::Omit(new_skip) => {831							// +1 including this core832							data.omitted_until = data833								.omitted_until834								.max(omit_index + new_skip + Saturating(1));835						}836						EnumFields::Normal(Visibility::Normal) => {837							if data.omitted_until <= omit_index && data.exists_visible.is_none() {838								data.exists_visible = Some(Visibility::Normal);839							}840						}841						EnumFields::Normal(Visibility::Hidden) => {842							if data.omitted_until <= omit_index {843								data.exists_visible = Some(match data.exists_visible {844									// We're iterating in reverse, later unhide is preserved845									Some(Visibility::Unhide) => Visibility::Unhide,846									_ => Visibility::Hidden,847								});848							}849						}850						EnumFields::Normal(Visibility::Unhide) => {851							if data.omitted_until <= omit_index {852								data.exists_visible = Some(match data.exists_visible {853									// We're iterating in reverse, later hide is preserved854									Some(Visibility::Hidden) => Visibility::Hidden,855									_ => Visibility::Unhide,856								});857							}858						}859					}860					ControlFlow::Continue(())861				});862863			super_depth.deepen();864			omit_index += 1;865		}866867		out.retain(|_, v| v.exists_visible.is_some());868869		out870	}871	pub fn fields_ex(872		&self,873		include_hidden: bool,874		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,875	) -> Vec<IStr> {876		#[cfg(feature = "exp-preserve-order")]877		if preserve_order {878			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self879				.fields_visibility()880				.into_iter()881				.filter(|(_, d)| include_hidden || d.visible())882				.enumerate()883				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))884				.unzip();885			keys.sort_unstable_by_key(|v| v.0);886			// Reorder in-place by resulting indexes887			for i in 0..fields.len() {888				let x = fields[i].clone();889				let mut j = i;890				loop {891					let k = keys[j].1;892					keys[j].1 = j;893					if k == i {894						break;895					}896					fields[j] = fields[k].clone();897					j = k;898				}899				fields[j] = x;900			}901			return fields;902		}903904		let mut fields: Vec<_> = self905			.fields_visibility()906			.into_iter()907			.filter(|(_, d)| include_hidden || d.visible())908			.map(|(k, _)| k)909			.collect();910		fields.sort_unstable();911		fields912	}913	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {914		self.fields_ex(915			false,916			#[cfg(feature = "exp-preserve-order")]917			preserve_order,918		)919	}920	pub fn values_ex(921		&self,922		include_hidden: bool,923		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,924	) -> ArrValue {925		ArrValue::new(PickObjectValues::new(926			self.clone(),927			self.fields_ex(928				include_hidden,929				#[cfg(feature = "exp-preserve-order")]930				preserve_order,931			),932		))933	}934	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {935		self.values_ex(936			false,937			#[cfg(feature = "exp-preserve-order")]938			preserve_order,939		)940	}941	pub fn key_values_ex(942		&self,943		include_hidden: bool,944		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,945	) -> ArrValue {946		ArrValue::new(PickObjectKeyValues::new(947			self.clone(),948			self.fields_ex(949				include_hidden,950				#[cfg(feature = "exp-preserve-order")]951				preserve_order,952			),953		))954	}955	pub fn key_values(956		&self,957		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,958	) -> ArrValue {959		self.key_values_ex(960			false,961			#[cfg(feature = "exp-preserve-order")]962			preserve_order,963		)964	}965}966967#[allow(clippy::module_name_repetitions)]968#[must_use = "value not added unless binding() was called"]969pub struct ObjMemberBuilder<Kind> {970	kind: Kind,971	name: IStr,972	add: bool,973	visibility: Visibility,974	original_index: FieldIndex,975	location: Option<Span>,976}977978#[allow(clippy::missing_const_for_fn)]979impl<Kind> ObjMemberBuilder<Kind> {980	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {981		Self {982			kind,983			name,984			original_index,985			add: false,986			visibility: Visibility::Normal,987			location: None,988		}989	}990991	pub const fn with_add(mut self, add: bool) -> Self {992		self.add = add;993		self994	}995	pub fn add(self) -> Self {996		self.with_add(true)997	}998	pub fn with_visibility(mut self, visibility: Visibility) -> Self {999		self.visibility = visibility;1000		self1001	}1002	pub fn hide(self) -> Self {1003		self.with_visibility(Visibility::Hidden)1004	}1005	pub fn with_location(mut self, location: Span) -> Self {1006		self.location = Some(location);1007		self1008	}1009	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1010		(1011			self.kind,1012			self.name,1013			ObjMember {1014				flags: ObjFieldFlags::new(self.add, self.visibility),1015				original_index: self.original_index,1016				invoke: binding,1017				location: self.location,1018			},1019		)1020	}1021}10221023pub struct ExtendBuilder<'v>(&'v mut ObjValue);1024impl ObjMemberBuilder<ExtendBuilder<'_>> {1025	pub fn value(self, value: impl Into<Val>) {1026		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1027	}1028	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1029		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1030	}1031	pub fn binding(self, binding: MaybeUnbound) {1032		let (receiver, name, member) = self.build_member(binding);1033		let new = receiver.0.clone();1034		*receiver.0 = new.extend_with_raw_member(name, member);1035	}1036}