git.delta.rocks / jrsonnet / refs/commits / 1ddb92c00d0f

1use std::{2	any::Any,3	cell::{Cell, RefCell},4	clone::Clone,5	collections::hash_map::Entry,6	fmt::{self, Debug},7	hash::{Hash, Hasher},8	num::Saturating,9	ops::ControlFlow,10};1112use educe::Educe;13use jrsonnet_gcmodule::{cc_dyn, Acyclic, Cc, Trace, Weak};14use jrsonnet_interner::IStr;15use jrsonnet_parser::Span;16use rustc_hash::{FxHashMap, FxHashSet};1718mod oop;1920pub use jrsonnet_parser::Visibility;21pub use oop::ObjValueBuilder;2223use crate::{24	arr::{PickObjectKeyValues, PickObjectValues},25	bail,26	error::{suggest_object_fields, ErrorKind::*},27	identity_hash,28	operator::evaluate_add_op,29	val::{ArrValue, ThunkValue},30	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,31};3233#[cfg(not(feature = "exp-preserve-order"))]34pub mod ordering {35	#![allow(36		// This module works as stub for preserve-order feature37		clippy::unused_self,38	)]3940	use jrsonnet_gcmodule::Trace;4142	#[derive(Clone, Copy, Default, Debug, Trace)]43	pub struct FieldIndex(());44	impl FieldIndex {45		pub fn absolute(_v: u32) -> Self {46			Self(())47		}48		pub const fn next(self) -> Self {49			Self(())50		}51	}5253	#[derive(Clone, Copy, Default, Debug, Trace)]54	pub struct SuperDepth(());55	impl SuperDepth {56		pub(super) fn deepen(self) {}57	}58}5960#[cfg(feature = "exp-preserve-order")]61pub mod ordering {62	use std::cmp::Reverse;6364	use jrsonnet_gcmodule::Trace;6566	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]67	pub struct FieldIndex(u32);68	impl FieldIndex {69		pub fn absolute(v: u32) -> Self {70			Self(v)71		}72		pub fn next(self) -> Self {73			Self(self.0 + 1)74		}75	}7677	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]78	pub struct SuperDepth(u32);79	impl SuperDepth {80		pub(super) fn deepen(&mut self) {81			self.0 += 182		}83	}8485	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]86	pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);87	impl FieldSortKey {88		pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {89			Self(Reverse(depth), index)90		}91	}92}9394#[cfg(feature = "exp-preserve-order")]95use ordering::FieldSortKey;96use ordering::{FieldIndex, SuperDepth};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;161162pub enum EnumFields {163	Normal(Visibility),164	Omit(Skip),165}166167#[derive(Trace, Clone)]168pub enum GetFor {169	// Return value170	Final(Val),171	// Continue iterating over cores, add current value to sum stack172	SuperPlus(Val),173	// Ignore the field value, stop at this layer instead174	Omit(#[trace(skip)] Skip),175	NotFound,176}177178#[derive(Acyclic, Clone)]179pub enum FieldVisibility {180	Found(Visibility),181	Omit(Skip),182	NotFound,183}184185#[derive(Acyclic, Clone)]186pub enum HasFieldIncludeHidden {187	Exists,188	NotFound,189	Omit(Skip),190}191192type Skip = Saturating<usize>;193194pub trait ObjectCore: Trace + Any + Debug {195	// If callback returns false, iteration stops, and this call returns false.196	fn enum_fields_core(197		&self,198		super_depth: &mut SuperDepth,199		handler: &mut EnumFieldsHandler<'_>,200	) -> bool;201202	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;203204	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;205	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;206207	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;208}209210#[derive(Clone, Trace)]211pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);212impl Debug for WeakObjValue {213	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {214		f.debug_tuple("WeakObjValue").finish()215	}216}217218impl PartialEq for WeakObjValue {219	fn eq(&self, other: &Self) -> bool {220		Weak::ptr_eq(&self.0, &other.0)221	}222}223224impl Eq for WeakObjValue {}225impl Hash for WeakObjValue {226	fn hash<H: Hasher>(&self, hasher: &mut H) {227		// Safety: usize is POD228		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };229		hasher.write_usize(addr);230	}231}232233cc_dyn!(234	#[derive(Clone, Debug)]235	CcObjectCore, ObjectCore,236	pub fn new() {...}237);238#[derive(Trace, Educe)]239#[educe(Debug)]240struct ObjValueInner {241	cores: Vec<CcObjectCore>,242	assertions_ran: Cell<bool>,243	value_cache: RefCell<FxHashMap<(IStr, CoreIdx), CacheValue>>,244}245246thread_local! {247	static RUNNING_ASSERTIONS: RefCell<FxHashSet<ObjValue>> = RefCell::default();248}249fn is_asserting(obj: &ObjValue) -> bool {250	RUNNING_ASSERTIONS.with_borrow(|v| v.contains(obj))251}252/// Returns false if already asserting253fn start_asserting(obj: &ObjValue) -> bool {254	RUNNING_ASSERTIONS.with_borrow_mut(|v| v.insert(obj.clone()))255}256fn finish_asserting(obj: &ObjValue) {257	RUNNING_ASSERTIONS.with_borrow_mut(|v| {258		let r = v.remove(obj);259		debug_assert!(260			r,261			"finish_asserting was called before start_asserting or twice"262		);263	});264}265266thread_local! {267	static EMPTY_OBJ: ObjValue = ObjValue(Cc::new(ObjValueInner {268		cores: vec![],269		assertions_ran: Cell::new(true),270		value_cache: RefCell::default(),271	}))272}273274#[allow(clippy::module_name_repetitions)]275#[derive(Clone, Trace, Debug, Educe)]276#[educe(PartialEq, Hash, Eq)]277pub struct ObjValue(278	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,279);280281impl ObjValue {282	pub fn empty() -> Self {283		EMPTY_OBJ.with(Clone::clone)284	}285	pub fn is_empty(&self) -> bool {286		self.0.cores.is_empty() || self.len() == 0287	}288}289290#[derive(Trace, Debug)]291struct StandaloneSuperCore {292	sup: CoreIdx,293	this: ObjValue,294}295impl ObjectCore for StandaloneSuperCore {296	fn enum_fields_core(297		&self,298		super_depth: &mut SuperDepth,299		handler: &mut EnumFieldsHandler<'_>,300	) -> bool {301		self.this.enum_fields_idx(super_depth, handler, self.sup)302	}303304	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {305		if self.this.has_field_include_hidden_idx(name, self.sup) {306			HasFieldIncludeHidden::Exists307		} else {308			HasFieldIncludeHidden::NotFound309		}310	}311312	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {313		if omit_only {314			return Ok(GetFor::NotFound);315		}316		let v = self.this.get_idx(key, self.sup)?;317		Ok(v.map_or(GetFor::NotFound, GetFor::Final))318	}319320	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {321		self.this322			.field_visibility_idx(field, self.sup)323			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)324	}325326	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {327		self.this.run_assertions()328	}329}330331#[derive(Debug, Acyclic)]332struct OmitFieldsCore {333	omit: FxHashSet<IStr>,334	prev_layers: usize,335}336impl ObjectCore for OmitFieldsCore {337	fn enum_fields_core(338		&self,339		super_depth: &mut SuperDepth,340		handler: &mut EnumFieldsHandler<'_>,341	) -> bool {342		let mut fi = FieldIndex::default();343		for f in &self.omit {344			if handler(345				*super_depth,346				fi,347				f.clone(),348				EnumFields::Omit(Saturating(self.prev_layers)),349			) == ControlFlow::Break(())350			{351				return false;352			}353			fi = fi.next();354		}355		true356	}357358	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {359		if self.omit.contains(&name) {360			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));361		}362		HasFieldIncludeHidden::NotFound363	}364365	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {366		if self.omit.contains(&key) {367			return Ok(GetFor::Omit(Saturating(self.prev_layers)));368		}369		Ok(GetFor::NotFound)370	}371372	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {373		if self.omit.contains(&field) {374			return FieldVisibility::Omit(Saturating(self.prev_layers));375		}376		FieldVisibility::NotFound377	}378379	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {380		Ok(())381	}382}383384#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]385struct CoreIdx {386	idx: usize,387}388impl CoreIdx {389	fn super_exists(self) -> bool {390		self.idx != 0391	}392}393#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]394pub struct SupThis {395	sup: CoreIdx,396	this: ObjValue,397}398impl SupThis {399	pub fn has_super(&self) -> bool {400		self.sup.super_exists()401	}402	/// Implementation of `"field" in super` operation,403	/// works faster than standalone super path.404	///405	/// In case of no `super` existence, returns false.406	pub fn field_in_super(&self, field: IStr) -> bool {407		self.this.has_field_include_hidden_idx(field, self.sup)408	}409	/// Implementation of `super.field` operation,410	/// works faster than standalone super path.411	///412	/// In case of no `super` existence, returns `NoSuperFound`413	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {414		if !self.sup.super_exists() {415			bail!(NoSuperFound);416		}417		self.this.get_idx(field, self.sup)418	}419	/// `super` with `self` overriden for top-level lookups.420	/// Exists when super appears outside of `super.field`/`"field" in super` expressions421	/// Exclusive to jrsonnet.422	///423	/// Might return `NoSuperFound` error.424	pub fn standalone_super(&self) -> Result<ObjValue> {425		if !self.sup.super_exists() {426			bail!(NoSuperFound)427		}428		let mut out = ObjValue::builder();429		out.reserve_cores(1).extend_with_core(StandaloneSuperCore {430			sup: self.sup,431			this: self.this.clone(),432		});433		Ok(out.build())434	}435	pub fn this(&self) -> &ObjValue {436		&self.this437	}438	pub fn downgrade(self) -> WeakSupThis {439		WeakSupThis {440			sup: self.sup,441			this: self.this.downgrade(),442		}443	}444}445#[derive(Trace, PartialEq, Eq, Hash, Debug)]446pub struct WeakSupThis {447	sup: CoreIdx,448	this: WeakObjValue,449}450451impl ObjValue {452	pub fn builder() -> ObjValueBuilder {453		ObjValueBuilder::new()454	}455	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {456		ObjValueBuilder::with_capacity(capacity)457	}458	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {459		let mut out = ObjValueBuilder::with_capacity(1);460		out.with_super(self);461		let mut member = out.field(key);462		if value.flags.add() {463			member = member.add();464		}465		if let Some(loc) = value.location {466			member = member.with_location(loc);467		}468		let _ = member469			.with_visibility(value.flags.visibility())470			.binding(value.invoke);471		out.build()472	}473	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {474		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())475	}476477	pub fn extend(&mut self) -> ObjValueBuilder {478		let mut out = ObjValueBuilder::new();479		out.with_super(self.clone());480		out481	}482483	#[must_use]484	pub fn extend_from(&self, sup: Self) -> Self {485		let mut cores = sup.0.cores.clone();486		cores.extend(self.0.cores.iter().cloned());487		ObjValue(Cc::new(ObjValueInner {488			cores,489			value_cache: RefCell::default(),490			assertions_ran: Cell::new(false),491		}))492	}493	// #[must_use]494	// pub fn with_this(&self, this: Self) -> Self {495	// 	self.0.with_this(self.clone(), this)496	// }497	/// Returns amount of visible object fields498	/// If object only contains hidden fields - may return zero.499	pub fn len(&self) -> usize {500		self.fields_visibility()501			.values()502			.filter(|d| d.visible())503			.count()504	}505	/// For each field, calls callback.506	/// If callback returns false - ends iteration prematurely.507	///508	/// Returns false if ended prematurely509	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {510		let mut super_depth = SuperDepth::default();511		self.enum_fields_idx(512			&mut super_depth,513			handler,514			CoreIdx {515				idx: self.0.cores.len(),516			},517		)518	}519	fn enum_fields_idx(520		&self,521		super_depth: &mut SuperDepth,522		handler: &mut EnumFieldsHandler<'_>,523		idx: CoreIdx,524	) -> bool {525		for core in self.0.cores[..idx.idx].iter().rev() {526			if !core.0.enum_fields_core(super_depth, handler) {527				return false;528			}529			super_depth.deepen();530		}531		true532	}533534	pub fn has_field_include_hidden(&self, name: IStr) -> bool {535		self.has_field_include_hidden_idx(536			name,537			CoreIdx {538				idx: self.0.cores.len(),539			},540		)541	}542	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {543		let mut skip = Saturating(0usize);544		for ele in self.0.cores[..core.idx].iter().rev() {545			match ele.0.has_field_include_hidden_core(name.clone()) {546				HasFieldIncludeHidden::Exists => {547					if skip.0 == 0 {548						return true;549					}550				}551				HasFieldIncludeHidden::Omit(new_skip) => {552					// +1 including this core553					skip = skip.max(new_skip + Saturating(1));554				}555				HasFieldIncludeHidden::NotFound => {}556			}557			skip -= 1;558		}559		false560	}561	pub fn has_field(&self, name: IStr) -> bool {562		match self.field_visibility(name) {563			Some(Visibility::Unhide | Visibility::Normal) => true,564			Some(Visibility::Hidden) | None => false,565		}566	}567	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {568		if include_hidden {569			self.has_field_include_hidden(name)570		} else {571			self.has_field(name)572		}573	}574	pub fn get(&self, key: IStr) -> Result<Option<Val>> {575		self.get_idx(576			key,577			CoreIdx {578				idx: self.0.cores.len(),579			},580		)581	}582583	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {584		let cache_key = (key.clone(), core);585		{586			let mut cache = self.0.value_cache.borrow_mut();587			// entry_ref candidate?588			match cache.entry(cache_key.clone()) {589				Entry::Occupied(v) => match v.get() {590					CacheValue::Cached(v) => return v.clone(),591					CacheValue::Pending => {592						if !is_asserting(self) {593							bail!(InfiniteRecursionDetected);594						}595					}596				},597				Entry::Vacant(v) => {598					v.insert(CacheValue::Pending);599				}600			};601		}602		let result = self.get_idx_uncached(key, core);603		{604			let mut cache = self.0.value_cache.borrow_mut();605			cache.insert(cache_key, CacheValue::Cached(result.clone()));606		}607		result608	}609	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {610		self.run_assertions()?;611		let mut add_stack = Vec::with_capacity(2);612		let mut skip = Saturating(0);613		for (sup, core) in self.0.cores[..core.idx].iter().enumerate().rev() {614			let sup_this = SupThis {615				sup: CoreIdx { idx: sup },616				this: self.clone(),617			};618			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {619				GetFor::Final(val) if add_stack.is_empty() => {620					if skip.0 == 0 {621						return Ok(Some(val));622					}623				}624				GetFor::Final(val) => {625					if skip.0 == 0 {626						add_stack.push(val);627						break;628					}629				}630				GetFor::SuperPlus(val) => {631					if skip.0 == 0 {632						add_stack.push(val);633					}634				}635				GetFor::Omit(new_skip) => {636					// +1 including this core637					skip = skip.max(new_skip + Saturating(1));638				}639				GetFor::NotFound => {}640			}641			skip -= 1;642		}643		if add_stack.is_empty() {644			// None of layers had this field645			return Ok(None);646		} else if add_stack.len() == 1 {647			// A layer had this field, but it wanted this field to be added with super.648			// However, no super had this field, fail-safe649			return Ok(Some(add_stack.pop().expect("single element on stack")));650		}651		let mut values = add_stack.into_iter().rev();652		let init = values.next().expect("at least 2 elements");653654		values655			.try_fold(init, |a, b| evaluate_add_op(&a, &b))656			.map(Some)657658		// self.0.get_raw(key, this)659	}660661	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {662		let Some(value) = self.get(key.clone())? else {663			let suggestions = suggest_object_fields(self, key.clone());664			bail!(NoSuchField(key, suggestions))665		};666		Ok(value)667	}668669	fn field_visibility(&self, field: IStr) -> Option<Visibility> {670		self.field_visibility_idx(671			field,672			CoreIdx {673				idx: self.0.cores.len(),674			},675		)676	}677	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {678		let mut exists = false;679		let mut skip = Saturating(0usize);680		for ele in self.0.cores[..core.idx].iter().rev() {681			let vis = ele.0.field_visibility_core(field.clone());682			match vis {683				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {684					if skip.0 == 0 {685						return Some(vis);686					}687				}688				FieldVisibility::Found(Visibility::Normal) => {689					if skip.0 == 0 {690						exists = true;691					}692				}693				FieldVisibility::NotFound => {}694				FieldVisibility::Omit(new_skip) => {695					// +1 including this core696					skip = skip.max(new_skip + Saturating(1));697				}698			}699			skip -= 1;700		}701		exists.then_some(Visibility::Normal)702	}703704	pub fn run_assertions(&self) -> Result<()> {705		if self.0.assertions_ran.get() {706			return Ok(());707		}708		if !start_asserting(self) {709			return Ok(());710		}711		for (idx, ele) in self.0.cores.iter().enumerate() {712			let sup_this = SupThis {713				sup: CoreIdx { idx },714				this: self.clone(),715			};716			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {717				finish_asserting(self);718			})?;719		}720		finish_asserting(self);721		self.0.assertions_ran.set(true);722		Ok(())723	}724725	pub fn iter(726		&self,727		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,728	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {729		let fields = self.fields(730			#[cfg(feature = "exp-preserve-order")]731			preserve_order,732		);733		fields.into_iter().map(|field| {734			(735				field.clone(),736				self.get(field)737					.map(|opt| opt.expect("iterating over keys, field exists")),738			)739		})740	}741	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {742		#[derive(Trace)]743		struct ObjFieldThunk {744			obj: ObjValue,745			key: IStr,746		}747		impl ThunkValue for ObjFieldThunk {748			type Output = Val;749750			fn get(&self) -> Result<Self::Output> {751				self.obj752					.get(self.key.clone())753					.transpose()754					.expect("field existence checked")755			}756		}757758		if !self.has_field_ex(key.clone(), true) {759			return None;760		}761762		Some(Thunk::new(ObjFieldThunk {763			obj: self.clone(),764			key,765		}))766	}767	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {768		#[derive(Trace)]769		struct ObjFieldThunk {770			obj: ObjValue,771			key: IStr,772		}773		impl ThunkValue for ObjFieldThunk {774			type Output = Val;775776			fn get(&self) -> Result<Self::Output> {777				self.obj.get_or_bail(self.key.clone())778			}779		}780781		Thunk::new(ObjFieldThunk {782			obj: self.clone(),783			key,784		})785	}786	pub fn ptr_eq(a: &Self, b: &Self) -> bool {787		Cc::ptr_eq(&a.0, &b.0)788	}789	pub fn downgrade(self) -> WeakObjValue {790		WeakObjValue(self.0.downgrade())791	}792}793794#[derive(Debug)]795struct FieldVisibilityData {796	omitted_until: Saturating<usize>,797	exists_visible: Option<Visibility>,798	#[cfg(feature = "exp-preserve-order")]799	key: FieldSortKey,800}801impl FieldVisibilityData {802	fn visible(&self) -> bool {803		self.exists_visible804			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")805			.is_visible()806	}807	#[cfg(feature = "exp-preserve-order")]808	fn sort_key(&self) -> FieldSortKey {809		self.key810	}811}812813impl ObjValue {814	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {815		let mut out = FxHashMap::default();816817		let mut super_depth = SuperDepth::default();818		let mut omit_index = Saturating(0);819		for core in self.0.cores.iter().rev() {820			core.0821				.enum_fields_core(&mut super_depth, &mut |_depth, _index, name, visibility| {822					let entry = out.entry(name);823					let data = entry.or_insert(FieldVisibilityData {824						exists_visible: None,825						#[cfg(feature = "exp-preserve-order")]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}