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

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 jrsonnet_gcmodule::{Acyclic, Cc, Trace, Weak, cc_dyn};15use jrsonnet_interner::IStr;16use jrsonnet_ir::Span;17use rustc_hash::{FxHashMap, FxHashSet};1819mod oop;2021pub use jrsonnet_ir::Visibility;22pub use oop::ObjValueBuilder;2324use crate::{25	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,26	arr::{PickObjectKeyValues, PickObjectValues},27	bail,28	error::{ErrorKind::*, suggest_object_fields},29	identity_hash,30	operator::evaluate_add_op,31	val::{ArrValue, ThunkValue},32};3334#[cfg(not(feature = "exp-preserve-order"))]35pub mod ordering {36	#![allow(37		// This module works as stub for preserve-order feature38		clippy::unused_self,39	)]4041	use jrsonnet_gcmodule::Trace;4243	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]44	pub struct FieldIndex(());45	impl FieldIndex {46		pub fn absolute(_v: u32) -> Self {47			Self(())48		}49		#[must_use]50		pub const fn next(self) -> Self {51			Self(())52		}53	}5455	#[derive(Clone, Copy, Default, Debug, Trace, PartialEq, Eq, PartialOrd, Ord)]56	pub struct SuperDepth(());57	impl SuperDepth {58		pub(super) fn deepen(self) {}59	}60}6162#[cfg(feature = "exp-preserve-order")]63pub mod ordering {64	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		#[must_use]73		pub fn next(self) -> Self {74			Self(self.0 + 1)75		}76	}7778	#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Debug)]79	pub struct SuperDepth(u32);80	impl SuperDepth {81		pub(super) fn deepen(&mut self) {82			self.0 += 1;83		}84	}85}8687use ordering::{FieldIndex, SuperDepth};8889#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]90pub struct FieldSortKey(Reverse<SuperDepth>, FieldIndex);91impl FieldSortKey {92	pub fn new(depth: SuperDepth, index: FieldIndex) -> Self {93		Self(Reverse(depth), index)94	}95}9697// 0 - add98//  12 - visibility99#[derive(Clone, Copy)]100pub struct ObjFieldFlags(u8);101impl ObjFieldFlags {102	fn new(add: bool, visibility: Visibility) -> Self {103		let mut v = 0;104		if add {105			v |= 1;106		}107		v |= match visibility {108			Visibility::Normal => 0b000,109			Visibility::Hidden => 0b010,110			Visibility::Unhide => 0b100,111		};112		Self(v)113	}114	pub fn add(&self) -> bool {115		self.0 & 1 != 0116	}117	pub fn visibility(&self) -> Visibility {118		match (self.0 & 0b110) >> 1 {119			0b00 => Visibility::Normal,120			0b01 => Visibility::Hidden,121			0b10 => Visibility::Unhide,122			_ => unreachable!(),123		}124	}125}126impl Debug for ObjFieldFlags {127	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {128		f.debug_struct("ObjFieldFlags")129			.field("add", &self.add())130			.field("visibility", &self.visibility())131			.finish()132	}133}134135#[allow(clippy::module_name_repetitions)]136#[derive(Debug, Trace)]137pub struct ObjMember {138	#[trace(skip)]139	flags: ObjFieldFlags,140	original_index: FieldIndex,141	pub invoke: MaybeUnbound,142	pub location: Option<Span>,143}144145cc_dyn!(CcObjectAssertion, ObjectAssertion);146pub trait ObjectAssertion: Trace {147	fn run(&self, sup_this: SupThis) -> Result<()>;148}149150// Field => This151152#[derive(Trace, Debug)]153enum CacheValue {154	Cached(Result<Option<Val>>),155	Pending,156}157158pub type EnumFieldsHandler<'a> =159	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;160161#[derive(Debug)]162pub 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	has_assertions: bool,244	value_cache: RefCell<FxHashMap<(IStr, CoreIdx), CacheValue>>,245}246247thread_local! {248	static RUNNING_ASSERTIONS: RefCell<FxHashSet<ObjValue>> = RefCell::default();249}250fn is_asserting(obj: &ObjValue) -> bool {251	RUNNING_ASSERTIONS.with_borrow(|v| v.contains(obj))252}253/// Returns false if already asserting254fn start_asserting(obj: &ObjValue) -> bool {255	RUNNING_ASSERTIONS.with_borrow_mut(|v| v.insert(obj.clone()))256}257fn finish_asserting(obj: &ObjValue) {258	RUNNING_ASSERTIONS.with_borrow_mut(|v| {259		let r = v.remove(obj);260		debug_assert!(261			r,262			"finish_asserting was called before start_asserting or twice"263		);264	});265}266267thread_local! {268	static EMPTY_OBJ: ObjValue = ObjValue(Cc::new(ObjValueInner {269		cores: vec![],270		assertions_ran: Cell::new(true),271		has_assertions: false,272		value_cache: RefCell::default(),273	}))274}275276#[allow(clippy::module_name_repetitions)]277#[derive(Clone, Trace, Debug, Educe)]278#[educe(PartialEq, Hash, Eq)]279pub struct ObjValue(280	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,281);282283impl ObjValue {284	pub fn empty() -> Self {285		EMPTY_OBJ.with(Clone::clone)286	}287	pub fn is_empty(&self) -> bool {288		self.0.cores.is_empty() || self.len() == 0289	}290}291292#[derive(Trace, Debug)]293pub(crate) struct StandaloneSuperCore {294	sup: CoreIdx,295	this: ObjValue,296}297impl ObjectCore for StandaloneSuperCore {298	fn enum_fields_core(299		&self,300		super_depth: &mut SuperDepth,301		handler: &mut EnumFieldsHandler<'_>,302	) -> bool {303		self.this.enum_fields_idx(super_depth, handler, self.sup)304	}305306	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {307		if self.this.has_field_include_hidden_idx(name, self.sup) {308			HasFieldIncludeHidden::Exists309		} else {310			HasFieldIncludeHidden::NotFound311		}312	}313314	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {315		if omit_only {316			return Ok(GetFor::NotFound);317		}318		let v = self.this.get_idx(key, self.sup)?;319		Ok(v.map_or(GetFor::NotFound, GetFor::Final))320	}321322	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {323		self.this324			.field_visibility_idx(field, self.sup)325			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)326	}327328	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {329		self.this.run_assertions()330	}331}332333#[derive(Debug, Acyclic)]334struct OmitFieldsCore {335	omit: FxHashSet<IStr>,336	prev_layers: usize,337}338impl ObjectCore for OmitFieldsCore {339	fn enum_fields_core(340		&self,341		super_depth: &mut SuperDepth,342		handler: &mut EnumFieldsHandler<'_>,343	) -> bool {344		let mut fi = FieldIndex::default();345		for f in &self.omit {346			if handler(347				*super_depth,348				fi,349				f.clone(),350				EnumFields::Omit(Saturating(self.prev_layers)),351			) == ControlFlow::Break(())352			{353				return false;354			}355			fi = fi.next();356		}357		true358	}359360	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {361		if self.omit.contains(&name) {362			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));363		}364		HasFieldIncludeHidden::NotFound365	}366367	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {368		if self.omit.contains(&key) {369			return Ok(GetFor::Omit(Saturating(self.prev_layers)));370		}371		Ok(GetFor::NotFound)372	}373374	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {375		if self.omit.contains(&field) {376			return FieldVisibility::Omit(Saturating(self.prev_layers));377		}378		FieldVisibility::NotFound379	}380381	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {382		Ok(())383	}384}385386#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]387struct CoreIdx {388	idx: usize,389}390impl CoreIdx {391	fn super_exists(self) -> bool {392		self.idx != 0393	}394}395#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]396pub struct SupThis {397	sup: CoreIdx,398	this: ObjValue,399}400impl SupThis {401	pub fn has_super(&self) -> bool {402		self.sup.super_exists()403	}404	/// Implementation of `"field" in super` operation,405	/// works faster than standalone super path.406	///407	/// In case of no `super` existence, returns false.408	pub fn field_in_super(&self, field: IStr) -> bool {409		self.this.has_field_include_hidden_idx(field, self.sup)410	}411	/// Implementation of `super.field` operation,412	/// works faster than standalone super path.413	///414	/// In case of no `super` existence, returns `NoSuperFound`415	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {416		if !self.sup.super_exists() {417			bail!(NoSuperFound);418		}419		self.this.get_idx(field, self.sup)420	}421	/// `super` with `self` overriden for top-level lookups.422	/// Exists when super appears outside of `super.field`/`"field" in super` expressions423	/// Exclusive to jrsonnet.424	///425	/// Might return `NoSuperFound` error.426	pub fn standalone_super(&self) -> Result<ObjValue> {427		if !self.sup.super_exists() {428			bail!(NoSuperFound)429		}430		let mut out = ObjValue::builder();431		out.reserve_cores(1).extend_with_core(StandaloneSuperCore {432			sup: self.sup,433			this: self.this.clone(),434		});435		Ok(out.build())436	}437	pub fn this(&self) -> &ObjValue {438		&self.this439	}440	pub fn downgrade(self) -> WeakSupThis {441		WeakSupThis {442			sup: self.sup,443			this: self.this.downgrade(),444		}445	}446}447#[derive(Trace, PartialEq, Eq, Hash, Debug)]448pub struct WeakSupThis {449	sup: CoreIdx,450	this: WeakObjValue,451}452453impl ObjValue {454	pub fn builder() -> ObjValueBuilder {455		ObjValueBuilder::new()456	}457	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {458		ObjValueBuilder::with_capacity(capacity)459	}460	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {461		let mut out = ObjValueBuilder::with_capacity(1);462		out.with_super(self);463		let mut member = out.field(key);464		if value.flags.add() {465			member = member.add();466		}467		if let Some(loc) = value.location {468			member = member.with_location(loc);469		}470		let _ = member471			.with_visibility(value.flags.visibility())472			.binding(value.invoke);473		out.build()474	}475	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {476		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())477	}478479	pub fn extend(&mut self) -> ObjValueBuilder {480		let mut out = ObjValueBuilder::new();481		out.with_super(self.clone());482		out483	}484485	#[must_use]486	pub fn extend_from(&self, sup: Self) -> Self {487		let mut cores = Vec::with_capacity(sup.0.cores.len() + self.0.cores.len());488		cores.extend(sup.0.cores.iter().cloned());489		cores.extend(self.0.cores.iter().cloned());490		let has_assertions = sup.0.has_assertions || self.0.has_assertions;491		ObjValue(Cc::new(ObjValueInner {492			cores,493			value_cache: RefCell::default(),494			assertions_ran: Cell::new(!has_assertions),495			has_assertions,496		}))497	}498	// #[must_use]499	// pub fn with_this(&self, this: Self) -> Self {500	// 	self.0.with_this(self.clone(), this)501	// }502	/// Returns amount of visible object fields503	/// If object only contains hidden fields - may return zero.504	pub fn len(&self) -> usize {505		self.fields_visibility()506			.values()507			.filter(|d| d.visible())508			.count()509	}510	/// For each field, calls callback.511	/// If callback returns false - ends iteration prematurely.512	///513	/// Returns false if ended prematurely514	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {515		let mut super_depth = SuperDepth::default();516		self.enum_fields_idx(517			&mut super_depth,518			handler,519			CoreIdx {520				idx: self.0.cores.len(),521			},522		)523	}524	fn enum_fields_idx(525		&self,526		super_depth: &mut SuperDepth,527		handler: &mut EnumFieldsHandler<'_>,528		idx: CoreIdx,529	) -> bool {530		for core in self.0.cores[..idx.idx].iter().rev() {531			if !core.0.enum_fields_core(super_depth, handler) {532				return false;533			}534			super_depth.deepen();535		}536		true537	}538539	pub fn has_field_include_hidden(&self, name: IStr) -> bool {540		self.has_field_include_hidden_idx(541			name,542			CoreIdx {543				idx: self.0.cores.len(),544			},545		)546	}547	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {548		let mut skip = Saturating(0usize);549		for ele in self.0.cores[..core.idx].iter().rev() {550			match ele.0.has_field_include_hidden_core(name.clone()) {551				HasFieldIncludeHidden::Exists => {552					if skip.0 == 0 {553						return true;554					}555				}556				HasFieldIncludeHidden::Omit(new_skip) => {557					// +1 including this core558					skip = skip.max(new_skip + Saturating(1));559				}560				HasFieldIncludeHidden::NotFound => {}561			}562			skip -= 1;563		}564		false565	}566	pub fn has_field(&self, name: IStr) -> bool {567		match self.field_visibility(name) {568			Some(Visibility::Unhide | Visibility::Normal) => true,569			Some(Visibility::Hidden) | None => false,570		}571	}572	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {573		if include_hidden {574			self.has_field_include_hidden(name)575		} else {576			self.has_field(name)577		}578	}579	pub fn get(&self, key: IStr) -> Result<Option<Val>> {580		self.get_idx(581			key,582			CoreIdx {583				idx: self.0.cores.len(),584			},585		)586	}587588	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {589		let cache_key = (key.clone(), core);590		{591			let mut cache = self.0.value_cache.borrow_mut();592			// entry_ref candidate?593			match cache.entry(cache_key.clone()) {594				Entry::Occupied(v) => match v.get() {595					CacheValue::Cached(v) => return v.clone(),596					CacheValue::Pending => {597						if !is_asserting(self) {598							bail!(InfiniteRecursionDetected);599						}600					}601				},602				Entry::Vacant(v) => {603					v.insert(CacheValue::Pending);604				}605			};606		}607		let result = self.get_idx_uncached(key, core);608		{609			let mut cache = self.0.value_cache.borrow_mut();610			cache.insert(cache_key, CacheValue::Cached(result.clone()));611		}612		result613	}614	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {615		self.run_assertions()?;616		let mut first_add = None;617		let mut add_stack: Vec<Val> = Vec::new();618		let mut skip = Saturating(0);619		for (sup, core) in self.0.cores[..core.idx].iter().enumerate().rev() {620			let sup_this = SupThis {621				sup: CoreIdx { idx: sup },622				this: self.clone(),623			};624			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {625				GetFor::Final(val) if first_add.is_none() => {626					if skip.0 == 0 {627						return Ok(Some(val));628					}629				}630				GetFor::Final(val) => {631					if skip.0 == 0 {632						add_stack.push(val);633						break;634					}635				}636				GetFor::SuperPlus(val) => {637					if skip.0 == 0 {638						if first_add.is_none() {639							first_add = Some(val);640						} else {641							add_stack.push(val);642						}643					}644				}645				GetFor::Omit(new_skip) => {646					skip = skip.max(new_skip + Saturating(1));647				}648				GetFor::NotFound => {}649			}650			skip -= 1;651		}652		let Some(first) = first_add else {653			if add_stack.is_empty() {654				return Ok(None);655			}656			return Ok(Some(add_stack.pop().expect("single element on stack")));657		};658		if add_stack.is_empty() {659			return Ok(Some(first));660		}661		add_stack.insert(0, first);662		let mut values = add_stack.into_iter().rev();663		let init = values.next().expect("at least 2 elements");664665		values666			.try_fold(init, |a, b| evaluate_add_op(&a, &b))667			.map(Some)668	}669670	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {671		let Some(value) = self.get(key.clone())? else {672			let suggestions = suggest_object_fields(self, key.clone());673			bail!(NoSuchField(key, suggestions))674		};675		Ok(value)676	}677678	fn field_visibility(&self, field: IStr) -> Option<Visibility> {679		self.field_visibility_idx(680			field,681			CoreIdx {682				idx: self.0.cores.len(),683			},684		)685	}686	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {687		let mut exists = false;688		let mut skip = Saturating(0usize);689		for ele in self.0.cores[..core.idx].iter().rev() {690			let vis = ele.0.field_visibility_core(field.clone());691			match vis {692				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {693					if skip.0 == 0 {694						return Some(vis);695					}696				}697				FieldVisibility::Found(Visibility::Normal) => {698					if skip.0 == 0 {699						exists = true;700					}701				}702				FieldVisibility::NotFound => {}703				FieldVisibility::Omit(new_skip) => {704					// +1 including this core705					skip = skip.max(new_skip + Saturating(1));706				}707			}708			skip -= 1;709		}710		exists.then_some(Visibility::Normal)711	}712713	pub fn run_assertions(&self) -> Result<()> {714		if self.0.assertions_ran.get() {715			return Ok(());716		}717		if !start_asserting(self) {718			return Ok(());719		}720		for (idx, ele) in self.0.cores.iter().enumerate() {721			let sup_this = SupThis {722				sup: CoreIdx { idx },723				this: self.clone(),724			};725			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {726				finish_asserting(self);727			})?;728		}729		finish_asserting(self);730		self.0.assertions_ran.set(true);731		Ok(())732	}733734	pub fn iter(735		&self,736		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,737	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {738		let fields = self.fields(739			#[cfg(feature = "exp-preserve-order")]740			preserve_order,741		);742		fields.into_iter().map(|field| {743			(744				field.clone(),745				self.get(field)746					.map(|opt| opt.expect("iterating over keys, field exists")),747			)748		})749	}750	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {751		#[derive(Trace)]752		struct ObjFieldThunk {753			obj: ObjValue,754			key: IStr,755		}756		impl ThunkValue for ObjFieldThunk {757			type Output = Val;758759			fn get(&self) -> Result<Self::Output> {760				self.obj761					.get(self.key.clone())762					.transpose()763					.expect("field existence checked")764			}765		}766767		if !self.has_field_ex(key.clone(), true) {768			return None;769		}770771		Some(Thunk::new(ObjFieldThunk {772			obj: self.clone(),773			key,774		}))775	}776	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {777		#[derive(Trace)]778		struct ObjFieldThunk {779			obj: ObjValue,780			key: IStr,781		}782		impl ThunkValue for ObjFieldThunk {783			type Output = Val;784785			fn get(&self) -> Result<Self::Output> {786				self.obj.get_or_bail(self.key.clone())787			}788		}789790		Thunk::new(ObjFieldThunk {791			obj: self.clone(),792			key,793		})794	}795796	#[allow(dead_code, reason = "used in object ...rest destructuring")]797	pub(crate) fn as_standalone(&self) -> StandaloneSuperCore {798		StandaloneSuperCore {799			sup: CoreIdx {800				idx: self.0.cores.len(),801			},802			this: self.clone(),803		}804	}805	pub fn ptr_eq(a: &Self, b: &Self) -> bool {806		Cc::ptr_eq(&a.0, &b.0)807	}808	pub fn downgrade(self) -> WeakObjValue {809		WeakObjValue(self.0.downgrade())810	}811}812813#[derive(Debug)]814struct FieldVisibilityData {815	omitted_until: Saturating<usize>,816	exists_visible: Option<Visibility>,817	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]818	key: FieldSortKey,819}820impl FieldVisibilityData {821	fn visible(&self) -> bool {822		self.exists_visible823			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")824			.is_visible()825	}826	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]827	fn sort_key(&self) -> FieldSortKey {828		self.key829	}830}831832impl ObjValue {833	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {834		let mut out = FxHashMap::default();835836		let mut super_depth = SuperDepth::default();837		let mut omit_index = Saturating(0);838		for core in self.0.cores.iter().rev() {839			core.0840				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {841					let entry = out.entry(name);842					let data = entry.or_insert_with(|| FieldVisibilityData {843						exists_visible: None,844						key: FieldSortKey::new(depth, index),845						omitted_until: omit_index,846					});847					match visibility {848						EnumFields::Omit(new_skip) => {849							// +1 including this core850							data.omitted_until = data851								.omitted_until852								.max(omit_index + new_skip + Saturating(1));853						}854						EnumFields::Normal(Visibility::Normal) => {855							if data.omitted_until <= omit_index && data.exists_visible.is_none() {856								data.exists_visible = Some(Visibility::Normal);857							}858						}859						EnumFields::Normal(Visibility::Hidden) => {860							if data.omitted_until <= omit_index {861								data.exists_visible = Some(match data.exists_visible {862									// We're iterating in reverse, later unhide is preserved863									Some(Visibility::Unhide) => Visibility::Unhide,864									_ => Visibility::Hidden,865								});866							}867						}868						EnumFields::Normal(Visibility::Unhide) => {869							if data.omitted_until <= omit_index {870								data.exists_visible = Some(match data.exists_visible {871									// We're iterating in reverse, later hide is preserved872									Some(Visibility::Hidden) => Visibility::Hidden,873									_ => Visibility::Unhide,874								});875							}876						}877					}878					ControlFlow::Continue(())879				});880881			super_depth.deepen();882			omit_index += 1;883		}884885		out.retain(|_, v| v.exists_visible.is_some());886887		out888	}889	pub fn fields_ex(890		&self,891		include_hidden: bool,892		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,893	) -> Vec<IStr> {894		#[cfg(feature = "exp-preserve-order")]895		if preserve_order {896			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self897				.fields_visibility()898				.into_iter()899				.filter(|(_, d)| include_hidden || d.visible())900				.enumerate()901				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))902				.unzip();903			keys.sort_unstable_by_key(|v| v.0);904			// Reorder in-place by resulting indexes905			for i in 0..fields.len() {906				let x = fields[i].clone();907				let mut j = i;908				loop {909					let k = keys[j].1;910					keys[j].1 = j;911					if k == i {912						break;913					}914					fields[j] = fields[k].clone();915					j = k;916				}917				fields[j] = x;918			}919			return fields;920		}921922		let mut fields: Vec<_> = self923			.fields_visibility()924			.into_iter()925			.filter(|(_, d)| include_hidden || d.visible())926			.map(|(k, _)| k)927			.collect();928		fields.sort_unstable();929		fields930	}931	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {932		self.fields_ex(933			false,934			#[cfg(feature = "exp-preserve-order")]935			preserve_order,936		)937	}938	pub fn values_ex(939		&self,940		include_hidden: bool,941		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,942	) -> ArrValue {943		ArrValue::new(PickObjectValues::new(944			self.clone(),945			self.fields_ex(946				include_hidden,947				#[cfg(feature = "exp-preserve-order")]948				preserve_order,949			),950		))951	}952	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {953		self.values_ex(954			false,955			#[cfg(feature = "exp-preserve-order")]956			preserve_order,957		)958	}959	pub fn key_values_ex(960		&self,961		include_hidden: bool,962		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,963	) -> ArrValue {964		ArrValue::new(PickObjectKeyValues::new(965			self.clone(),966			self.fields_ex(967				include_hidden,968				#[cfg(feature = "exp-preserve-order")]969				preserve_order,970			),971		))972	}973	pub fn key_values(974		&self,975		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,976	) -> ArrValue {977		self.key_values_ex(978			false,979			#[cfg(feature = "exp-preserve-order")]980			preserve_order,981		)982	}983}984985#[allow(clippy::module_name_repetitions)]986#[must_use = "value not added unless binding() was called"]987pub struct ObjMemberBuilder<Kind> {988	kind: Kind,989	name: IStr,990	add: bool,991	visibility: Visibility,992	original_index: FieldIndex,993	location: Option<Span>,994}995996#[allow(clippy::missing_const_for_fn)]997impl<Kind> ObjMemberBuilder<Kind> {998	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {999		Self {1000			kind,1001			name,1002			original_index,1003			add: false,1004			visibility: Visibility::Normal,1005			location: None,1006		}1007	}10081009	pub const fn with_add(mut self, add: bool) -> Self {1010		self.add = add;1011		self1012	}1013	pub fn add(self) -> Self {1014		self.with_add(true)1015	}1016	pub fn with_visibility(mut self, visibility: Visibility) -> Self {1017		self.visibility = visibility;1018		self1019	}1020	pub fn hide(self) -> Self {1021		self.with_visibility(Visibility::Hidden)1022	}1023	pub fn with_location(mut self, location: Span) -> Self {1024		self.location = Some(location);1025		self1026	}1027	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1028		(1029			self.kind,1030			self.name,1031			ObjMember {1032				flags: ObjFieldFlags::new(self.add, self.visibility),1033				original_index: self.original_index,1034				invoke: binding,1035				location: self.location,1036			},1037		)1038	}1039}10401041pub struct ExtendBuilder<'v>(&'v mut ObjValue);1042impl ObjMemberBuilder<ExtendBuilder<'_>> {1043	pub fn value(self, value: impl Into<Val>) {1044		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1045	}1046	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1047		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1048	}1049	pub fn binding(self, binding: MaybeUnbound) {1050		let (receiver, name, member) = self.build_member(binding);1051		let new = receiver.0.clone();1052		*receiver.0 = new.extend_with_raw_member(name, member);1053	}1054}