git.delta.rocks / jrsonnet / refs/commits / 7da68eaa8a4d

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::{cc_dyn, Acyclic, Cc, Trace, Weak};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	arr::{PickObjectKeyValues, PickObjectValues},26	bail,27	error::{suggest_object_fields, ErrorKind::*},28	identity_hash,29	operator::evaluate_add_op,30	val::{ArrValue, ThunkValue},31	CcUnbound, MaybeUnbound, Result, Thunk, Unbound, Val,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;160161pub enum EnumFields {162	Normal(Visibility),163	Omit(Skip),164}165166#[derive(Trace, Clone)]167pub enum GetFor {168	// Return value169	Final(Val),170	// Continue iterating over cores, add current value to sum stack171	SuperPlus(Val),172	// Ignore the field value, stop at this layer instead173	Omit(#[trace(skip)] Skip),174	NotFound,175}176177#[derive(Acyclic, Clone)]178pub enum FieldVisibility {179	Found(Visibility),180	Omit(Skip),181	NotFound,182}183184#[derive(Acyclic, Clone)]185pub enum HasFieldIncludeHidden {186	Exists,187	NotFound,188	Omit(Skip),189}190191type Skip = Saturating<usize>;192193pub trait ObjectCore: Trace + Any + Debug {194	// If callback returns false, iteration stops, and this call returns false.195	fn enum_fields_core(196		&self,197		super_depth: &mut SuperDepth,198		handler: &mut EnumFieldsHandler<'_>,199	) -> bool;200201	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;202203	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;204	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;205206	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;207}208209#[derive(Clone, Trace)]210pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);211impl Debug for WeakObjValue {212	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {213		f.debug_tuple("WeakObjValue").finish()214	}215}216217impl PartialEq for WeakObjValue {218	fn eq(&self, other: &Self) -> bool {219		Weak::ptr_eq(&self.0, &other.0)220	}221}222223impl Eq for WeakObjValue {}224impl Hash for WeakObjValue {225	fn hash<H: Hasher>(&self, hasher: &mut H) {226		// Safety: usize is POD227		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };228		hasher.write_usize(addr);229	}230}231232cc_dyn!(233	#[derive(Clone, Debug)]234	CcObjectCore, ObjectCore,235	pub fn new() {...}236);237#[derive(Trace, Educe)]238#[educe(Debug)]239struct ObjValueInner {240	cores: Vec<CcObjectCore>,241	assertions_ran: Cell<bool>,242	#[trace(skip)]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)]293struct 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	}795	pub fn ptr_eq(a: &Self, b: &Self) -> bool {796		Cc::ptr_eq(&a.0, &b.0)797	}798	pub fn downgrade(self) -> WeakObjValue {799		WeakObjValue(self.0.downgrade())800	}801}802803#[derive(Debug)]804struct FieldVisibilityData {805	omitted_until: Saturating<usize>,806	exists_visible: Option<Visibility>,807	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]808	key: FieldSortKey,809}810impl FieldVisibilityData {811	fn visible(&self) -> bool {812		self.exists_visible813			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")814			.is_visible()815	}816	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]817	fn sort_key(&self) -> FieldSortKey {818		self.key819	}820}821822impl ObjValue {823	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {824		let mut out = FxHashMap::default();825826		let mut super_depth = SuperDepth::default();827		let mut omit_index = Saturating(0);828		for core in self.0.cores.iter().rev() {829			core.0830				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {831					let entry = out.entry(name);832					let data = entry.or_insert_with(|| FieldVisibilityData {833						exists_visible: None,834						key: FieldSortKey::new(depth, index),835						omitted_until: omit_index,836					});837					match visibility {838						EnumFields::Omit(new_skip) => {839							// +1 including this core840							data.omitted_until = data841								.omitted_until842								.max(omit_index + new_skip + Saturating(1));843						}844						EnumFields::Normal(Visibility::Normal) => {845							if data.omitted_until <= omit_index && data.exists_visible.is_none() {846								data.exists_visible = Some(Visibility::Normal);847							}848						}849						EnumFields::Normal(Visibility::Hidden) => {850							if data.omitted_until <= omit_index {851								data.exists_visible = Some(match data.exists_visible {852									// We're iterating in reverse, later unhide is preserved853									Some(Visibility::Unhide) => Visibility::Unhide,854									_ => Visibility::Hidden,855								});856							}857						}858						EnumFields::Normal(Visibility::Unhide) => {859							if data.omitted_until <= omit_index {860								data.exists_visible = Some(match data.exists_visible {861									// We're iterating in reverse, later hide is preserved862									Some(Visibility::Hidden) => Visibility::Hidden,863									_ => Visibility::Unhide,864								});865							}866						}867					}868					ControlFlow::Continue(())869				});870871			super_depth.deepen();872			omit_index += 1;873		}874875		out.retain(|_, v| v.exists_visible.is_some());876877		out878	}879	pub fn fields_ex(880		&self,881		include_hidden: bool,882		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,883	) -> Vec<IStr> {884		#[cfg(feature = "exp-preserve-order")]885		if preserve_order {886			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self887				.fields_visibility()888				.into_iter()889				.filter(|(_, d)| include_hidden || d.visible())890				.enumerate()891				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))892				.unzip();893			keys.sort_unstable_by_key(|v| v.0);894			// Reorder in-place by resulting indexes895			for i in 0..fields.len() {896				let x = fields[i].clone();897				let mut j = i;898				loop {899					let k = keys[j].1;900					keys[j].1 = j;901					if k == i {902						break;903					}904					fields[j] = fields[k].clone();905					j = k;906				}907				fields[j] = x;908			}909			return fields;910		}911912		let mut fields: Vec<_> = self913			.fields_visibility()914			.into_iter()915			.filter(|(_, d)| include_hidden || d.visible())916			.map(|(k, _)| k)917			.collect();918		fields.sort_unstable();919		fields920	}921	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {922		self.fields_ex(923			false,924			#[cfg(feature = "exp-preserve-order")]925			preserve_order,926		)927	}928	pub fn values_ex(929		&self,930		include_hidden: bool,931		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,932	) -> ArrValue {933		ArrValue::new(PickObjectValues::new(934			self.clone(),935			self.fields_ex(936				include_hidden,937				#[cfg(feature = "exp-preserve-order")]938				preserve_order,939			),940		))941	}942	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {943		self.values_ex(944			false,945			#[cfg(feature = "exp-preserve-order")]946			preserve_order,947		)948	}949	pub fn key_values_ex(950		&self,951		include_hidden: bool,952		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,953	) -> ArrValue {954		ArrValue::new(PickObjectKeyValues::new(955			self.clone(),956			self.fields_ex(957				include_hidden,958				#[cfg(feature = "exp-preserve-order")]959				preserve_order,960			),961		))962	}963	pub fn key_values(964		&self,965		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,966	) -> ArrValue {967		self.key_values_ex(968			false,969			#[cfg(feature = "exp-preserve-order")]970			preserve_order,971		)972	}973}974975#[allow(clippy::module_name_repetitions)]976#[must_use = "value not added unless binding() was called"]977pub struct ObjMemberBuilder<Kind> {978	kind: Kind,979	name: IStr,980	add: bool,981	visibility: Visibility,982	original_index: FieldIndex,983	location: Option<Span>,984}985986#[allow(clippy::missing_const_for_fn)]987impl<Kind> ObjMemberBuilder<Kind> {988	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {989		Self {990			kind,991			name,992			original_index,993			add: false,994			visibility: Visibility::Normal,995			location: None,996		}997	}998999	pub const fn with_add(mut self, add: bool) -> Self {1000		self.add = add;1001		self1002	}1003	pub fn add(self) -> Self {1004		self.with_add(true)1005	}1006	pub fn with_visibility(mut self, visibility: Visibility) -> Self {1007		self.visibility = visibility;1008		self1009	}1010	pub fn hide(self) -> Self {1011		self.with_visibility(Visibility::Hidden)1012	}1013	pub fn with_location(mut self, location: Span) -> Self {1014		self.location = Some(location);1015		self1016	}1017	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1018		(1019			self.kind,1020			self.name,1021			ObjMember {1022				flags: ObjFieldFlags::new(self.add, self.visibility),1023				original_index: self.original_index,1024				invoke: binding,1025				location: self.location,1026			},1027		)1028	}1029}10301031pub struct ExtendBuilder<'v>(&'v mut ObjValue);1032impl ObjMemberBuilder<ExtendBuilder<'_>> {1033	pub fn value(self, value: impl Into<Val>) {1034		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1035	}1036	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1037		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1038	}1039	pub fn binding(self, binding: MaybeUnbound) {1040		let (receiver, name, member) = self.build_member(binding);1041		let new = receiver.0.clone();1042		*receiver.0 = new.extend_with_raw_member(name, member);1043	}1044}