git.delta.rocks / jrsonnet / refs/commits / 86671948a995

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, Visibility};16use rustc_hash::{FxHashMap, FxHashSet};1718mod oop;1920pub use oop::ObjValueBuilder;2122use crate::{23	arr::{PickObjectKeyValues, PickObjectValues},24	bail,25	error::{suggest_object_fields, ErrorKind::*},26	identity_hash,27	operator::evaluate_add_op,28	val::{ArrValue, ThunkValue},29	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,30};3132#[cfg(not(feature = "exp-preserve-order"))]33mod ordering {34	#![allow(35		// This module works as stub for preserve-order feature36		clippy::unused_self,37	)]3839	use jrsonnet_gcmodule::Trace;4041	#[derive(Clone, Copy, Default, Debug, Trace)]42	pub struct FieldIndex(());43	impl FieldIndex {44		pub const fn next(self) -> Self {45			Self(())46		}47	}4849	#[derive(Clone, Copy, Default, Debug, Trace)]50	pub struct SuperDepth(());51	impl SuperDepth {52		pub(super) fn deepen(self) {}53	}54}5556#[cfg(feature = "exp-preserve-order")]57mod ordering {58	use std::cmp::Reverse;5960	use jrsonnet_gcmodule::Trace;6162	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]63	pub struct FieldIndex(u32);64	impl FieldIndex {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 += 175		}76	}7778	#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]79	pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);80	impl FieldSortKey {81		pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {82			Self(Reverse(depth), index)83		}84	}85}8687#[cfg(feature = "exp-preserve-order")]88use ordering::FieldSortKey;89use ordering::{FieldIndex, SuperDepth};9091// 0 - add92//  12 - visibility93#[derive(Clone, Copy)]94pub struct ObjFieldFlags(u8);95impl ObjFieldFlags {96	fn new(add: bool, visibility: Visibility) -> Self {97		let mut v = 0;98		if add {99			v |= 1;100		}101		v |= match visibility {102			Visibility::Normal => 0b000,103			Visibility::Hidden => 0b010,104			Visibility::Unhide => 0b100,105		};106		Self(v)107	}108	pub fn add(&self) -> bool {109		self.0 & 1 != 0110	}111	pub fn visibility(&self) -> Visibility {112		match (self.0 & 0b110) >> 1 {113			0b00 => Visibility::Normal,114			0b01 => Visibility::Hidden,115			0b10 => Visibility::Unhide,116			_ => unreachable!(),117		}118	}119}120impl Debug for ObjFieldFlags {121	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {122		f.debug_struct("ObjFieldFlags")123			.field("add", &self.add())124			.field("visibility", &self.visibility())125			.finish()126	}127}128129#[allow(clippy::module_name_repetitions)]130#[derive(Debug, Trace)]131pub struct ObjMember {132	#[trace(skip)]133	flags: ObjFieldFlags,134	original_index: FieldIndex,135	pub invoke: MaybeUnbound,136	pub location: Option<Span>,137}138139cc_dyn!(CcObjectAssertion, ObjectAssertion);140pub trait ObjectAssertion: Trace {141	fn run(&self, sup_this: SupThis) -> Result<()>;142}143144// Field => This145146#[derive(Trace, Debug)]147enum CacheValue {148	Cached(Result<Option<Val>>),149	Pending,150}151152type EnumFieldsHandler<'a> =153	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;154155pub enum EnumFields {156	Normal(Visibility),157	Omit(Skip),158}159160#[derive(Trace, Clone)]161pub enum GetFor {162	// Return value163	Final(Val),164	// Continue iterating over cores, add current value to sum stack165	SuperPlus(Val),166	// Ignore the field value, stop at this layer instead167	Omit(#[trace(skip)] Skip),168	NotFound,169}170171#[derive(Acyclic, Clone)]172pub enum FieldVisibility {173	Found(Visibility),174	Omit(Skip),175	NotFound,176}177178#[derive(Acyclic, Clone)]179pub enum HasFieldIncludeHidden {180	Exists,181	NotFound,182	Omit(Skip),183}184185type Skip = Saturating<usize>;186187pub trait ObjectCore: Trace + Any + Debug {188	// If callback returns false, iteration stops, and this call returns false.189	fn enum_fields_core(190		&self,191		super_depth: &mut SuperDepth,192		handler: &mut EnumFieldsHandler<'_>,193	) -> bool;194195	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;196197	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;198	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;199200	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;201}202203#[derive(Clone, Trace)]204pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);205impl Debug for WeakObjValue {206	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {207		f.debug_tuple("WeakObjValue").finish()208	}209}210211impl PartialEq for WeakObjValue {212	fn eq(&self, other: &Self) -> bool {213		Weak::ptr_eq(&self.0, &other.0)214	}215}216217impl Eq for WeakObjValue {}218impl Hash for WeakObjValue {219	fn hash<H: Hasher>(&self, hasher: &mut H) {220		// Safety: usize is POD221		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };222		hasher.write_usize(addr);223	}224}225226cc_dyn!(227	#[derive(Clone, Debug)]228	CcObjectCore, ObjectCore,229	pub fn new() {...}230);231#[derive(Trace, Educe)]232#[educe(Debug)]233struct ObjValueInner {234	cores: Vec<CcObjectCore>,235	assertions_ran: Cell<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		value_cache: RefCell::default(),264	}))265}266267#[allow(clippy::module_name_repetitions)]268#[derive(Clone, Trace, Debug, Educe)]269#[educe(PartialEq, Hash, Eq)]270pub struct ObjValue(271	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,272);273274impl ObjValue {275	pub fn empty() -> Self {276		EMPTY_OBJ.with(Clone::clone)277	}278	pub fn is_empty(&self) -> bool {279		self.0.cores.is_empty() || self.len() == 0280	}281}282283#[derive(Trace, Debug)]284struct StandaloneSuperCore {285	sup: CoreIdx,286	this: ObjValue,287}288impl ObjectCore for StandaloneSuperCore {289	fn enum_fields_core(290		&self,291		super_depth: &mut SuperDepth,292		handler: &mut EnumFieldsHandler<'_>,293	) -> bool {294		self.this.enum_fields_idx(super_depth, handler, self.sup)295	}296297	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {298		if self.this.has_field_include_hidden_idx(name, self.sup) {299			HasFieldIncludeHidden::Exists300		} else {301			HasFieldIncludeHidden::NotFound302		}303	}304305	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {306		if omit_only {307			return Ok(GetFor::NotFound);308		}309		let v = self.this.get_idx(key, self.sup)?;310		Ok(v.map_or(GetFor::NotFound, GetFor::Final))311	}312313	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {314		self.this315			.field_visibility_idx(field, self.sup)316			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)317	}318319	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {320		self.this.run_assertions()321	}322}323324#[derive(Debug, Acyclic)]325struct OmitFieldsCore {326	omit: FxHashSet<IStr>,327	prev_layers: usize,328}329impl ObjectCore for OmitFieldsCore {330	fn enum_fields_core(331		&self,332		super_depth: &mut SuperDepth,333		handler: &mut EnumFieldsHandler<'_>,334	) -> bool {335		let mut fi = FieldIndex::default();336		for f in &self.omit {337			if handler(338				*super_depth,339				fi,340				f.clone(),341				EnumFields::Omit(Saturating(self.prev_layers)),342			) == ControlFlow::Break(())343			{344				return false;345			}346			fi = fi.next();347		}348		true349	}350351	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {352		if self.omit.contains(&name) {353			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));354		}355		HasFieldIncludeHidden::NotFound356	}357358	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {359		if self.omit.contains(&key) {360			return Ok(GetFor::Omit(Saturating(self.prev_layers)));361		}362		Ok(GetFor::NotFound)363	}364365	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {366		if self.omit.contains(&field) {367			return FieldVisibility::Omit(Saturating(self.prev_layers));368		}369		FieldVisibility::NotFound370	}371372	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {373		Ok(())374	}375}376377#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]378struct CoreIdx {379	idx: usize,380}381impl CoreIdx {382	fn super_exists(self) -> bool {383		self.idx != 0384	}385}386#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]387pub struct SupThis {388	sup: CoreIdx,389	this: ObjValue,390}391impl SupThis {392	pub fn has_super(&self) -> bool {393		self.sup.super_exists()394	}395	/// Implementation of `"field" in super` operation,396	/// works faster than standalone super path.397	///398	/// In case of no `super` existence, returns false.399	pub fn field_in_super(&self, field: IStr) -> bool {400		self.this.has_field_include_hidden_idx(field, self.sup)401	}402	/// Implementation of `super.field` operation,403	/// works faster than standalone super path.404	///405	/// In case of no `super` existence, returns `NoSuperFound`406	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {407		if !self.sup.super_exists() {408			bail!(NoSuperFound);409		}410		self.this.get_idx(field, self.sup)411	}412	/// `super` with `self` overriden for top-level lookups.413	/// Exists when super appears outside of `super.field`/`"field" in super` expressions414	/// Exclusive to jrsonnet.415	///416	/// Might return `NoSuperFound` error.417	pub fn standalone_super(&self) -> Result<ObjValue> {418		if !self.sup.super_exists() {419			bail!(NoSuperFound)420		}421		let mut out = ObjValue::builder();422		out.reserve_cores(1).extend_with_core(StandaloneSuperCore {423			sup: self.sup,424			this: self.this.clone(),425		});426		Ok(out.build())427	}428	pub fn this(&self) -> &ObjValue {429		&self.this430	}431	pub fn downgrade(self) -> WeakSupThis {432		WeakSupThis {433			sup: self.sup,434			this: self.this.downgrade(),435		}436	}437}438#[derive(Trace, PartialEq, Eq, Hash, Debug)]439pub struct WeakSupThis {440	sup: CoreIdx,441	this: WeakObjValue,442}443444impl ObjValue {445	pub fn builder() -> ObjValueBuilder {446		ObjValueBuilder::new()447	}448	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {449		ObjValueBuilder::with_capacity(capacity)450	}451	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {452		let mut out = ObjValueBuilder::with_capacity(1);453		out.with_super(self);454		let mut member = out.field(key);455		if value.flags.add() {456			member = member.add();457		}458		if let Some(loc) = value.location {459			member = member.with_location(loc);460		}461		let _ = member462			.with_visibility(value.flags.visibility())463			.binding(value.invoke);464		out.build()465	}466	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {467		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())468	}469470	pub fn extend(&mut self) -> ObjValueBuilder {471		let mut out = ObjValueBuilder::new();472		out.with_super(self.clone());473		out474	}475476	#[must_use]477	pub fn extend_from(&self, sup: Self) -> Self {478		let mut cores = sup.0.cores.clone();479		cores.extend(self.0.cores.iter().cloned());480		ObjValue(Cc::new(ObjValueInner {481			cores,482			value_cache: RefCell::default(),483			assertions_ran: Cell::new(false),484		}))485	}486	// #[must_use]487	// pub fn with_this(&self, this: Self) -> Self {488	// 	self.0.with_this(self.clone(), this)489	// }490	/// Returns amount of visible object fields491	/// If object only contains hidden fields - may return zero.492	pub fn len(&self) -> usize {493		self.fields_visibility()494			.values()495			.filter(|d| d.visible())496			.count()497	}498	/// For each field, calls callback.499	/// If callback returns false - ends iteration prematurely.500	///501	/// Returns false if ended prematurely502	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {503		let mut super_depth = SuperDepth::default();504		self.enum_fields_idx(505			&mut super_depth,506			handler,507			CoreIdx {508				idx: self.0.cores.len(),509			},510		)511	}512	fn enum_fields_idx(513		&self,514		super_depth: &mut SuperDepth,515		handler: &mut EnumFieldsHandler<'_>,516		idx: CoreIdx,517	) -> bool {518		for core in self.0.cores[..idx.idx].iter().rev() {519			if !core.0.enum_fields_core(super_depth, handler) {520				return false;521			}522			super_depth.deepen();523		}524		true525	}526527	pub fn has_field_include_hidden(&self, name: IStr) -> bool {528		self.has_field_include_hidden_idx(529			name,530			CoreIdx {531				idx: self.0.cores.len(),532			},533		)534	}535	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {536		let mut skip = Saturating(0usize);537		for ele in self.0.cores[..core.idx].iter().rev() {538			match ele.0.has_field_include_hidden_core(name.clone()) {539				HasFieldIncludeHidden::Exists => {540					if skip.0 == 0 {541						return true;542					}543				}544				HasFieldIncludeHidden::Omit(new_skip) => {545					// +1 including this core546					skip = skip.max(new_skip + Saturating(1));547				}548				HasFieldIncludeHidden::NotFound => {}549			}550			skip -= 1;551		}552		false553	}554	pub fn has_field(&self, name: IStr) -> bool {555		match self.field_visibility(name) {556			Some(Visibility::Unhide | Visibility::Normal) => true,557			Some(Visibility::Hidden) | None => false,558		}559	}560	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {561		if include_hidden {562			self.has_field_include_hidden(name)563		} else {564			self.has_field(name)565		}566	}567	pub fn get(&self, key: IStr) -> Result<Option<Val>> {568		self.get_idx(569			key,570			CoreIdx {571				idx: self.0.cores.len(),572			},573		)574	}575576	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {577		let cache_key = (key.clone(), core);578		{579			let mut cache = self.0.value_cache.borrow_mut();580			// entry_ref candidate?581			match cache.entry(cache_key.clone()) {582				Entry::Occupied(v) => match v.get() {583					CacheValue::Cached(v) => return v.clone(),584					CacheValue::Pending => {585						if !is_asserting(self) {586							bail!(InfiniteRecursionDetected);587						}588					}589				},590				Entry::Vacant(v) => {591					v.insert(CacheValue::Pending);592				}593			};594		}595		let result = self.get_idx_uncached(key, core);596		{597			let mut cache = self.0.value_cache.borrow_mut();598			cache.insert(cache_key, CacheValue::Cached(result.clone()));599		}600		result601	}602	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {603		self.run_assertions()?;604		let mut add_stack = Vec::with_capacity(2);605		let mut skip = Saturating(0);606		for (sup, core) in self.0.cores[..core.idx].iter().enumerate().rev() {607			let sup_this = SupThis {608				sup: CoreIdx { idx: sup },609				this: self.clone(),610			};611			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {612				GetFor::Final(val) if add_stack.is_empty() => {613					if skip.0 == 0 {614						return Ok(Some(val));615					}616				}617				GetFor::Final(val) => {618					if skip.0 == 0 {619						add_stack.push(val);620						break;621					}622				}623				GetFor::SuperPlus(val) => {624					if skip.0 == 0 {625						add_stack.push(val);626					}627				}628				GetFor::Omit(new_skip) => {629					// +1 including this core630					skip = skip.max(new_skip + Saturating(1));631				}632				GetFor::NotFound => {}633			}634			skip -= 1;635		}636		if add_stack.is_empty() {637			// None of layers had this field638			return Ok(None);639		} else if add_stack.len() == 1 {640			// A layer had this field, but it wanted this field to be added with super.641			// However, no super had this field, fail-safe642			return Ok(Some(add_stack.pop().expect("single element on stack")));643		}644		let mut values = add_stack.into_iter().rev();645		let init = values.next().expect("at least 2 elements");646647		values648			.try_fold(init, |a, b| evaluate_add_op(&a, &b))649			.map(Some)650651		// self.0.get_raw(key, this)652	}653654	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {655		let Some(value) = self.get(key.clone())? else {656			let suggestions = suggest_object_fields(self, key.clone());657			bail!(NoSuchField(key, suggestions))658		};659		Ok(value)660	}661662	fn field_visibility(&self, field: IStr) -> Option<Visibility> {663		self.field_visibility_idx(664			field,665			CoreIdx {666				idx: self.0.cores.len(),667			},668		)669	}670	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {671		let mut exists = false;672		let mut skip = Saturating(0usize);673		for ele in self.0.cores[..core.idx].iter().rev() {674			let vis = ele.0.field_visibility_core(field.clone());675			match vis {676				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {677					if skip.0 == 0 {678						return Some(vis);679					}680				}681				FieldVisibility::Found(Visibility::Normal) => {682					if skip.0 == 0 {683						exists = true;684					}685				}686				FieldVisibility::NotFound => {}687				FieldVisibility::Omit(new_skip) => {688					// +1 including this core689					skip = skip.max(new_skip + Saturating(1));690				}691			}692			skip -= 1;693		}694		exists.then_some(Visibility::Normal)695	}696697	pub fn run_assertions(&self) -> Result<()> {698		if self.0.assertions_ran.get() {699			return Ok(());700		}701		if !start_asserting(self) {702			return Ok(());703		}704		for (idx, ele) in self.0.cores.iter().enumerate() {705			let sup_this = SupThis {706				sup: CoreIdx { idx },707				this: self.clone(),708			};709			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {710				finish_asserting(self);711			})?;712		}713		finish_asserting(self);714		self.0.assertions_ran.set(true);715		Ok(())716	}717718	pub fn iter(719		&self,720		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,721	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {722		let fields = self.fields(723			#[cfg(feature = "exp-preserve-order")]724			preserve_order,725		);726		fields.into_iter().map(|field| {727			(728				field.clone(),729				self.get(field)730					.map(|opt| opt.expect("iterating over keys, field exists")),731			)732		})733	}734	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {735		#[derive(Trace)]736		struct ObjFieldThunk {737			obj: ObjValue,738			key: IStr,739		}740		impl ThunkValue for ObjFieldThunk {741			type Output = Val;742743			fn get(&self) -> Result<Self::Output> {744				self.obj745					.get(self.key.clone())746					.transpose()747					.expect("field existence checked")748			}749		}750751		if !self.has_field_ex(key.clone(), true) {752			return None;753		}754755		Some(Thunk::new(ObjFieldThunk {756			obj: self.clone(),757			key,758		}))759	}760	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {761		#[derive(Trace)]762		struct ObjFieldThunk {763			obj: ObjValue,764			key: IStr,765		}766		impl ThunkValue for ObjFieldThunk {767			type Output = Val;768769			fn get(&self) -> Result<Self::Output> {770				self.obj.get_or_bail(self.key.clone())771			}772		}773774		Thunk::new(ObjFieldThunk {775			obj: self.clone(),776			key,777		})778	}779	pub fn ptr_eq(a: &Self, b: &Self) -> bool {780		Cc::ptr_eq(&a.0, &b.0)781	}782	pub fn downgrade(self) -> WeakObjValue {783		WeakObjValue(self.0.downgrade())784	}785}786787#[derive(Debug)]788struct FieldVisibilityData {789	omitted_until: Saturating<usize>,790	exists_visible: Option<Visibility>,791	#[cfg(feature = "exp-preserve-order")]792	key: FieldSortKey,793}794impl FieldVisibilityData {795	fn visible(&self) -> bool {796		self.exists_visible797			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")798			.is_visible()799	}800	#[cfg(feature = "exp-preserve-order")]801	fn sort_key(&self) -> FieldSortKey {802		self.key803	}804}805806impl ObjValue {807	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {808		let mut out = FxHashMap::default();809810		let mut super_depth = SuperDepth::default();811		let mut omit_index = Saturating(0);812		for core in self.0.cores.iter().rev() {813			core.0814				.enum_fields_core(&mut super_depth, &mut |_depth, _index, name, visibility| {815					let entry = out.entry(name);816					let data = entry.or_insert(FieldVisibilityData {817						exists_visible: None,818						#[cfg(feature = "exp-preserve-order")]819						key: FieldSortKey::new(_depth, _index),820						omitted_until: omit_index,821					});822					match visibility {823						EnumFields::Omit(new_skip) => {824							// +1 including this core825							data.omitted_until = data826								.omitted_until827								.max(omit_index + new_skip + Saturating(1));828						}829						EnumFields::Normal(Visibility::Normal) => {830							if data.omitted_until <= omit_index && data.exists_visible.is_none() {831								data.exists_visible = Some(Visibility::Normal);832							}833						}834						EnumFields::Normal(Visibility::Hidden) => {835							if data.omitted_until <= omit_index {836								data.exists_visible = Some(match data.exists_visible {837									// We're iterating in reverse, later unhide is preserved838									Some(Visibility::Unhide) => Visibility::Unhide,839									_ => Visibility::Hidden,840								});841							}842						}843						EnumFields::Normal(Visibility::Unhide) => {844							if data.omitted_until <= omit_index {845								data.exists_visible = Some(match data.exists_visible {846									// We're iterating in reverse, later hide is preserved847									Some(Visibility::Hidden) => Visibility::Hidden,848									_ => Visibility::Unhide,849								});850							}851						}852					}853					ControlFlow::Continue(())854				});855856			super_depth.deepen();857			omit_index += 1;858		}859860		out.retain(|_, v| v.exists_visible.is_some());861862		out863	}864	pub fn fields_ex(865		&self,866		include_hidden: bool,867		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,868	) -> Vec<IStr> {869		#[cfg(feature = "exp-preserve-order")]870		if preserve_order {871			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self872				.fields_visibility()873				.into_iter()874				.filter(|(_, d)| include_hidden || d.visible())875				.enumerate()876				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))877				.unzip();878			keys.sort_unstable_by_key(|v| v.0);879			// Reorder in-place by resulting indexes880			for i in 0..fields.len() {881				let x = fields[i].clone();882				let mut j = i;883				loop {884					let k = keys[j].1;885					keys[j].1 = j;886					if k == i {887						break;888					}889					fields[j] = fields[k].clone();890					j = k;891				}892				fields[j] = x;893			}894			return fields;895		}896897		let mut fields: Vec<_> = self898			.fields_visibility()899			.into_iter()900			.filter(|(_, d)| include_hidden || d.visible())901			.map(|(k, _)| k)902			.collect();903		fields.sort_unstable();904		fields905	}906	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {907		self.fields_ex(908			false,909			#[cfg(feature = "exp-preserve-order")]910			preserve_order,911		)912	}913	pub fn values_ex(914		&self,915		include_hidden: bool,916		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,917	) -> ArrValue {918		ArrValue::new(PickObjectValues::new(919			self.clone(),920			self.fields_ex(921				include_hidden,922				#[cfg(feature = "exp-preserve-order")]923				preserve_order,924			),925		))926	}927	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {928		self.values_ex(929			false,930			#[cfg(feature = "exp-preserve-order")]931			preserve_order,932		)933	}934	pub fn key_values_ex(935		&self,936		include_hidden: bool,937		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,938	) -> ArrValue {939		ArrValue::new(PickObjectKeyValues::new(940			self.clone(),941			self.fields_ex(942				include_hidden,943				#[cfg(feature = "exp-preserve-order")]944				preserve_order,945			),946		))947	}948	pub fn key_values(949		&self,950		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,951	) -> ArrValue {952		self.key_values_ex(953			false,954			#[cfg(feature = "exp-preserve-order")]955			preserve_order,956		)957	}958}959960#[allow(clippy::module_name_repetitions)]961#[must_use = "value not added unless binding() was called"]962pub struct ObjMemberBuilder<Kind> {963	kind: Kind,964	name: IStr,965	add: bool,966	visibility: Visibility,967	original_index: FieldIndex,968	location: Option<Span>,969}970971#[allow(clippy::missing_const_for_fn)]972impl<Kind> ObjMemberBuilder<Kind> {973	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {974		Self {975			kind,976			name,977			original_index,978			add: false,979			visibility: Visibility::Normal,980			location: None,981		}982	}983984	pub const fn with_add(mut self, add: bool) -> Self {985		self.add = add;986		self987	}988	pub fn add(self) -> Self {989		self.with_add(true)990	}991	pub fn with_visibility(mut self, visibility: Visibility) -> Self {992		self.visibility = visibility;993		self994	}995	pub fn hide(self) -> Self {996		self.with_visibility(Visibility::Hidden)997	}998	pub fn with_location(mut self, location: Span) -> Self {999		self.location = Some(location);1000		self1001	}1002	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1003		(1004			self.kind,1005			self.name,1006			ObjMember {1007				flags: ObjFieldFlags::new(self.add, self.visibility),1008				original_index: self.original_index,1009				invoke: binding,1010				location: self.location,1011			},1012		)1013	}1014}10151016pub struct ExtendBuilder<'v>(&'v mut ObjValue);1017impl ObjMemberBuilder<ExtendBuilder<'_>> {1018	pub fn value(self, value: impl Into<Val>) {1019		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1020	}1021	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1022		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1023	}1024	pub fn binding(self, binding: MaybeUnbound) {1025		let (receiver, name, member) = self.build_member(binding);1026		let new = receiver.0.clone();1027		*receiver.0 = new.extend_with_raw_member(name, member);1028	}1029}