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

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, arridx},27	bail,28	error::{ErrorKind::*, suggest_object_fields},29	evaluate::operator::evaluate_add_op,30	identity_hash,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, Acyclic)]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	flags: ObjFieldFlags,139	pub invoke: MaybeUnbound,140	pub location: Option<Span>,141}142143cc_dyn!(CcObjectAssertion, ObjectAssertion);144pub trait ObjectAssertion: Trace {145	fn run(&self, sup_this: SupThis) -> Result<()>;146}147148// Field => This149150#[derive(Trace, Debug)]151enum CacheValue {152	Cached(Result<Option<Val>>),153	Pending,154}155156pub type EnumFieldsHandler<'a> =157	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;158159#[derive(Debug)]160pub enum EnumFields {161	Normal(Visibility),162	Omit(Skip),163}164165#[derive(Trace, Clone)]166pub enum GetFor {167	// Return value168	Final(Val),169	// Continue iterating over cores, add current value to sum stack170	SuperPlus(Val),171	// Ignore the field value, stop at this layer instead172	Omit(#[trace(skip)] Skip),173	NotFound,174}175176#[derive(Acyclic, Clone)]177pub enum FieldVisibility {178	Found(Visibility),179	Omit(Skip),180	NotFound,181}182183#[derive(Acyclic, Clone)]184pub enum HasFieldIncludeHidden {185	Exists,186	NotFound,187	Omit(Skip),188}189190type Skip = Saturating<usize>;191192pub trait ObjectCore: Trace + Any + Debug {193	// If callback returns false, iteration stops, and this call returns false.194	fn enum_fields_core(195		&self,196		super_depth: &mut SuperDepth,197		handler: &mut EnumFieldsHandler<'_>,198	) -> bool;199200	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden;201202	fn get_for_core(&self, key: IStr, sup_this: SupThis, omit_only: bool) -> Result<GetFor>;203	fn field_visibility_core(&self, field: IStr) -> FieldVisibility;204205	fn run_assertions_core(&self, sup_this: SupThis) -> Result<()>;206}207208#[derive(Clone, Trace)]209pub struct WeakObjValue(#[trace(skip)] Weak<ObjValueInner>);210impl Debug for WeakObjValue {211	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {212		f.debug_tuple("WeakObjValue").finish()213	}214}215216impl PartialEq for WeakObjValue {217	fn eq(&self, other: &Self) -> bool {218		Weak::ptr_eq(&self.0, &other.0)219	}220}221222impl Eq for WeakObjValue {}223impl Hash for WeakObjValue {224	fn hash<H: Hasher>(&self, hasher: &mut H) {225		// Safety: usize is POD226		let addr = unsafe { *std::ptr::addr_of!(self.0).cast() };227		hasher.write_usize(addr);228	}229}230231cc_dyn!(232	#[derive(Clone, Debug)]233	CcObjectCore, ObjectCore,234	pub fn new() {...}235);236237#[derive(Trace, Educe)]238#[educe(Debug)]239struct ObjValueInner {240	cores: Vec<CcObjectCore>,241	assertions_ran: Cell<bool>,242	has_assertions: 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		has_assertions: false,271		value_cache: RefCell::default(),272	}))273}274275#[allow(clippy::module_name_repetitions)]276#[derive(Clone, Trace, Debug, Educe)]277#[educe(PartialEq, Hash, Eq)]278pub struct ObjValue(279	#[educe(PartialEq(method(Cc::ptr_eq)), Hash(method(identity_hash)))] Cc<ObjValueInner>,280);281282impl ObjValue {283	pub fn empty() -> Self {284		EMPTY_OBJ.with(Clone::clone)285	}286	pub fn is_empty(&self) -> bool {287		self.0.cores.is_empty() || self.len() == 0288	}289}290291#[derive(Trace, Debug)]292pub(crate) struct StandaloneSuperCore {293	sup: CoreIdx,294	this: ObjValue,295}296impl ObjectCore for StandaloneSuperCore {297	fn enum_fields_core(298		&self,299		super_depth: &mut SuperDepth,300		handler: &mut EnumFieldsHandler<'_>,301	) -> bool {302		self.this.enum_fields_idx(super_depth, handler, self.sup)303	}304305	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {306		if self.this.has_field_include_hidden_idx(name, self.sup) {307			HasFieldIncludeHidden::Exists308		} else {309			HasFieldIncludeHidden::NotFound310		}311	}312313	fn get_for_core(&self, key: IStr, _sup_this: SupThis, omit_only: bool) -> Result<GetFor> {314		if omit_only {315			return Ok(GetFor::NotFound);316		}317		let v = self.this.get_idx(key, self.sup)?;318		Ok(v.map_or(GetFor::NotFound, GetFor::Final))319	}320321	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {322		self.this323			.field_visibility_idx(field, self.sup)324			.map_or(FieldVisibility::NotFound, FieldVisibility::Found)325	}326327	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {328		self.this.run_assertions()329	}330}331332#[derive(Debug, Acyclic)]333struct OmitFieldsCore {334	omit: FxHashSet<IStr>,335	prev_layers: usize,336}337impl ObjectCore for OmitFieldsCore {338	fn enum_fields_core(339		&self,340		super_depth: &mut SuperDepth,341		handler: &mut EnumFieldsHandler<'_>,342	) -> bool {343		let mut fi = FieldIndex::default();344		for f in &self.omit {345			if handler(346				*super_depth,347				fi,348				f.clone(),349				EnumFields::Omit(Saturating(self.prev_layers)),350			) == ControlFlow::Break(())351			{352				return false;353			}354			fi = fi.next();355		}356		true357	}358359	fn has_field_include_hidden_core(&self, name: IStr) -> HasFieldIncludeHidden {360		if self.omit.contains(&name) {361			return HasFieldIncludeHidden::Omit(Saturating(self.prev_layers));362		}363		HasFieldIncludeHidden::NotFound364	}365366	fn get_for_core(&self, key: IStr, _sup_this: SupThis, _omit_only: bool) -> Result<GetFor> {367		if self.omit.contains(&key) {368			return Ok(GetFor::Omit(Saturating(self.prev_layers)));369		}370		Ok(GetFor::NotFound)371	}372373	fn field_visibility_core(&self, field: IStr) -> FieldVisibility {374		if self.omit.contains(&field) {375			return FieldVisibility::Omit(Saturating(self.prev_layers));376		}377		FieldVisibility::NotFound378	}379380	fn run_assertions_core(&self, _sup_this: SupThis) -> Result<()> {381		Ok(())382	}383}384385#[derive(Hash, PartialEq, Eq, Trace, Clone, Copy, Debug)]386struct CoreIdx {387	idx: usize,388}389impl CoreIdx {390	fn super_exists(self) -> bool {391		self.idx != 0392	}393}394#[derive(Trace, Clone, PartialEq, Eq, Hash, Debug)]395pub struct SupThis {396	sup: CoreIdx,397	this: ObjValue,398}399impl SupThis {400	/// Create a `SupThis` for a freshly constructed object (no super).401	pub fn new(this: ObjValue) -> Self {402		Self {403			sup: CoreIdx {404				idx: this.0.cores.len(),405			},406			this,407		}408	}409	pub fn has_super(&self) -> bool {410		self.sup.super_exists()411	}412	/// Implementation of `"field" in super` operation,413	/// works faster than standalone super path.414	///415	/// In case of no `super` existence, returns false.416	pub fn field_in_super(&self, field: IStr) -> bool {417		self.this.has_field_include_hidden_idx(field, self.sup)418	}419	/// Implementation of `super.field` operation,420	/// works faster than standalone super path.421	///422	/// In case of no `super` existence, returns `NoSuperFound`423	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {424		if !self.sup.super_exists() {425			bail!(NoSuperFound);426		}427		self.this.get_idx(field, self.sup)428	}429	/// `super` with `self` overriden for top-level lookups.430	/// Exists when super appears outside of `super.field`/`"field" in super` expressions431	/// Exclusive to jrsonnet.432	///433	/// Returns None if no `super` found434	pub fn standalone_super(&self) -> Option<ObjValue> {435		if !self.sup.super_exists() {436			return None;437		}438		let mut out = ObjValue::builder();439		out.extend_with_core(StandaloneSuperCore {440			sup: self.sup,441			this: self.this.clone(),442		});443		Some(out.build())444	}445	pub fn this(&self) -> &ObjValue {446		&self.this447	}448	pub fn downgrade(self) -> WeakSupThis {449		WeakSupThis {450			sup: self.sup,451			this: self.this.downgrade(),452		}453	}454}455#[derive(Trace, PartialEq, Eq, Hash, Debug)]456pub struct WeakSupThis {457	sup: CoreIdx,458	this: WeakObjValue,459}460461impl ObjValue {462	pub fn builder() -> ObjValueBuilder {463		ObjValueBuilder::new()464	}465	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {466		ObjValueBuilder::with_capacity(capacity)467	}468	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {469		let mut out = ObjValueBuilder::with_capacity(1);470		out.with_super(self);471		let mut member = out.field(key);472		if value.flags.add() {473			member = member.add();474		}475		if let Some(loc) = value.location {476			member = member.with_location(loc);477		}478		let _ = member479			.with_visibility(value.flags.visibility())480			.binding(value.invoke);481		out.build()482	}483	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {484		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())485	}486487	pub fn extend(&mut self) -> ObjValueBuilder {488		let mut out = ObjValueBuilder::new();489		out.with_super(self.clone());490		out491	}492493	#[must_use]494	pub fn extend_from(&self, sup: Self) -> Self {495		let mut cores = Vec::with_capacity(sup.0.cores.len() + self.0.cores.len());496		cores.extend(sup.0.cores.iter().cloned());497		cores.extend(self.0.cores.iter().cloned());498499		let has_assertions = sup.0.has_assertions || self.0.has_assertions;500		ObjValue(Cc::new(ObjValueInner {501			cores,502			value_cache: RefCell::default(),503			assertions_ran: Cell::new(!has_assertions),504			has_assertions,505		}))506	}507	// #[must_use]508	// pub fn with_this(&self, this: Self) -> Self {509	// 	self.0.with_this(self.clone(), this)510	// }511	/// Returns amount of visible object fields512	/// If object only contains hidden fields - may return zero.513	pub fn len(&self) -> usize {514		self.fields_visibility()515			.values()516			.filter(|d| d.visible())517			.count()518	}519	pub fn len32(&self) -> u32 {520		arridx(self.len())521	}522	/// For each field, calls callback.523	/// If callback returns false - ends iteration prematurely.524	///525	/// Returns false if ended prematurely526	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {527		let mut super_depth = SuperDepth::default();528		self.enum_fields_idx(529			&mut super_depth,530			handler,531			CoreIdx {532				idx: self.0.cores.len(),533			},534		)535	}536537	fn iter_cores(&self, idx: CoreIdx) -> impl Iterator<Item = &CcObjectCore> {538		self.0.cores.iter().take(idx.idx).rev()539	}540	fn iter_cores_enumerate(&self, idx: CoreIdx) -> impl Iterator<Item = (CoreIdx, &CcObjectCore)> {541		self.0542			.cores543			.iter()544			.take(idx.idx)545			.enumerate()546			.rev()547			.map(|(idx, o)| (CoreIdx { idx }, o))548	}549550	fn enum_fields_idx(551		&self,552		super_depth: &mut SuperDepth,553		handler: &mut EnumFieldsHandler<'_>,554		idx: CoreIdx,555	) -> bool {556		for core in self.iter_cores(idx) {557			if !core.0.enum_fields_core(super_depth, handler) {558				return false;559			}560			super_depth.deepen();561		}562		true563	}564565	pub fn has_field_include_hidden(&self, name: IStr) -> bool {566		self.has_field_include_hidden_idx(567			name,568			CoreIdx {569				idx: self.0.cores.len(),570			},571		)572	}573	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {574		let mut skip = Saturating(0usize);575		for ele in self.iter_cores(core) {576			match ele.0.has_field_include_hidden_core(name.clone()) {577				HasFieldIncludeHidden::Exists => {578					if skip.0 == 0 {579						return true;580					}581				}582				HasFieldIncludeHidden::Omit(new_skip) => {583					// +1 including this core584					skip = skip.max(new_skip + Saturating(1));585				}586				HasFieldIncludeHidden::NotFound => {}587			}588			skip -= 1;589		}590		false591	}592	pub fn has_field(&self, name: IStr) -> bool {593		match self.field_visibility(name) {594			Some(Visibility::Unhide | Visibility::Normal) => true,595			Some(Visibility::Hidden) | None => false,596		}597	}598	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {599		if include_hidden {600			self.has_field_include_hidden(name)601		} else {602			self.has_field(name)603		}604	}605	pub fn get(&self, key: IStr) -> Result<Option<Val>> {606		self.get_idx(607			key,608			CoreIdx {609				idx: self.0.cores.len(),610			},611		)612	}613614	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {615		let cache_key = (key.clone(), core);616		{617			let mut cache = self.0.value_cache.borrow_mut();618			// entry_ref candidate?619			match cache.entry(cache_key.clone()) {620				Entry::Occupied(v) => match v.get() {621					CacheValue::Cached(v) => return v.clone(),622					CacheValue::Pending => {623						if !is_asserting(self) {624							bail!(InfiniteRecursionDetected);625						}626					}627				},628				Entry::Vacant(v) => {629					v.insert(CacheValue::Pending);630				}631			}632		}633		let result = self.get_idx_uncached(key, core);634		{635			let mut cache = self.0.value_cache.borrow_mut();636			cache.insert(cache_key, CacheValue::Cached(result.clone()));637		}638		result639	}640	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {641		self.run_assertions()?;642		let mut first_add = None;643		let mut add_stack: Vec<Val> = Vec::new();644		let mut skip = Saturating(0);645		for (sup, core) in self.iter_cores_enumerate(core) {646			let sup_this = SupThis {647				sup,648				this: self.clone(),649			};650			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {651				GetFor::Final(val) if first_add.is_none() => {652					if skip.0 == 0 {653						return Ok(Some(val));654					}655				}656				GetFor::Final(val) => {657					if skip.0 == 0 {658						add_stack.push(val);659						break;660					}661				}662				GetFor::SuperPlus(val) => {663					if skip.0 == 0 {664						if first_add.is_none() {665							first_add = Some(val);666						} else {667							add_stack.push(val);668						}669					}670				}671				GetFor::Omit(new_skip) => {672					skip = skip.max(new_skip + Saturating(1));673				}674				GetFor::NotFound => {}675			}676			skip -= 1;677		}678		let Some(first) = first_add else {679			if add_stack.is_empty() {680				return Ok(None);681			}682			return Ok(Some(add_stack.pop().expect("single element on stack")));683		};684		if add_stack.is_empty() {685			return Ok(Some(first));686		}687		add_stack.insert(0, first);688		let mut values = add_stack.into_iter().rev();689		let init = values.next().expect("at least 2 elements");690691		values692			.try_fold(init, |a, b| evaluate_add_op(&a, &b))693			.map(Some)694	}695696	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {697		let Some(value) = self.get(key.clone())? else {698			let suggestions = suggest_object_fields(self, key.clone());699			bail!(NoSuchField(key, suggestions))700		};701		Ok(value)702	}703704	fn field_visibility(&self, field: IStr) -> Option<Visibility> {705		self.field_visibility_idx(706			field,707			CoreIdx {708				idx: self.0.cores.len(),709			},710		)711	}712	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {713		let mut exists = false;714		let mut skip = Saturating(0usize);715		for ele in self.iter_cores(core) {716			let vis = ele.0.field_visibility_core(field.clone());717			match vis {718				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {719					if skip.0 == 0 {720						return Some(vis);721					}722				}723				FieldVisibility::Found(Visibility::Normal) => {724					if skip.0 == 0 {725						exists = true;726					}727				}728				FieldVisibility::NotFound => {}729				FieldVisibility::Omit(new_skip) => {730					// +1 including this core731					skip = skip.max(new_skip + Saturating(1));732				}733			}734			skip -= 1;735		}736		exists.then_some(Visibility::Normal)737	}738739	pub fn run_assertions(&self) -> Result<()> {740		if self.0.assertions_ran.get() {741			return Ok(());742		}743		if !start_asserting(self) {744			return Ok(());745		}746		for (idx, ele) in self.0.cores.iter().enumerate() {747			let sup_this = SupThis {748				sup: CoreIdx { idx },749				this: self.clone(),750			};751			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {752				finish_asserting(self);753			})?;754		}755		finish_asserting(self);756		self.0.assertions_ran.set(true);757		Ok(())758	}759760	pub fn iter(761		&self,762		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,763	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {764		let fields = self.fields(765			#[cfg(feature = "exp-preserve-order")]766			preserve_order,767		);768		fields.into_iter().map(|field| {769			(770				field.clone(),771				self.get(field)772					.map(|opt| opt.expect("iterating over keys, field exists")),773			)774		})775	}776	pub fn get_lazy(&self, key: IStr) -> Option<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.obj787					.get(self.key.clone())788					.transpose()789					.expect("field existence checked")790			}791		}792793		if !self.has_field_ex(key.clone(), true) {794			return None;795		}796797		Some(Thunk::new(ObjFieldThunk {798			obj: self.clone(),799			key,800		}))801	}802	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {803		#[derive(Trace)]804		struct ObjFieldThunk {805			obj: ObjValue,806			key: IStr,807		}808		impl ThunkValue for ObjFieldThunk {809			type Output = Val;810811			fn get(&self) -> Result<Self::Output> {812				self.obj.get_or_bail(self.key.clone())813			}814		}815816		Thunk::new(ObjFieldThunk {817			obj: self.clone(),818			key,819		})820	}821822	#[allow(dead_code, reason = "used in object ...rest destructuring")]823	pub(crate) fn as_standalone(&self) -> StandaloneSuperCore {824		StandaloneSuperCore {825			sup: CoreIdx {826				idx: self.0.cores.len(),827			},828			this: self.clone(),829		}830	}831	pub fn ptr_eq(a: &Self, b: &Self) -> bool {832		Cc::ptr_eq(&a.0, &b.0)833	}834	pub fn downgrade(self) -> WeakObjValue {835		WeakObjValue(self.0.downgrade())836	}837}838839#[derive(Debug)]840struct FieldVisibilityData {841	omitted_until: Saturating<usize>,842	exists_visible: Option<Visibility>,843	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]844	key: FieldSortKey,845}846impl FieldVisibilityData {847	fn visible(&self) -> bool {848		self.exists_visible849			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")850			.is_visible()851	}852	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]853	fn sort_key(&self) -> FieldSortKey {854		self.key855	}856}857858impl ObjValue {859	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {860		let mut out = FxHashMap::default();861862		let mut super_depth = SuperDepth::default();863		let mut omit_index = Saturating(0);864		for core in self.0.cores.iter().rev() {865			core.0866				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {867					let entry = out.entry(name);868					let data = entry.or_insert_with(|| FieldVisibilityData {869						exists_visible: None,870						key: FieldSortKey::new(depth, index),871						omitted_until: omit_index,872					});873					match visibility {874						EnumFields::Omit(new_skip) => {875							// +1 including this core876							data.omitted_until = data877								.omitted_until878								.max(omit_index + new_skip + Saturating(1));879						}880						EnumFields::Normal(Visibility::Normal) => {881							if data.omitted_until <= omit_index && data.exists_visible.is_none() {882								data.exists_visible = Some(Visibility::Normal);883							}884						}885						EnumFields::Normal(Visibility::Hidden) => {886							if data.omitted_until <= omit_index {887								data.exists_visible = Some(match data.exists_visible {888									// We're iterating in reverse, later unhide is preserved889									Some(Visibility::Unhide) => Visibility::Unhide,890									_ => Visibility::Hidden,891								});892							}893						}894						EnumFields::Normal(Visibility::Unhide) => {895							if data.omitted_until <= omit_index {896								data.exists_visible = Some(match data.exists_visible {897									// We're iterating in reverse, later hide is preserved898									Some(Visibility::Hidden) => Visibility::Hidden,899									_ => Visibility::Unhide,900								});901							}902						}903					}904					ControlFlow::Continue(())905				});906907			super_depth.deepen();908			omit_index += 1;909		}910911		out.retain(|_, v| v.exists_visible.is_some());912913		out914	}915	pub fn fields_with_visibility(916		&self,917		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,918	) -> Vec<(IStr, Visibility)> {919		#[cfg(feature = "exp-preserve-order")]920		if preserve_order {921			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self922				.fields_visibility()923				.into_iter()924				.enumerate()925				.map(|(idx, (k, d))| {926					(927						(928							k,929							d.exists_visible.expect("non-existing fields filtered out"),930						),931						(d.sort_key(), idx),932					)933				})934				.unzip();935			keys.sort_unstable_by_key(|v| v.0);936			for i in 0..fields.len() {937				let x = fields[i].clone();938				let mut j = i;939				loop {940					let k = keys[j].1;941					keys[j].1 = j;942					if k == i {943						break;944					}945					fields[j] = fields[k].clone();946					j = k;947				}948				fields[j] = x;949			}950			return fields;951		}952		let mut fields: Vec<_> = self953			.fields_visibility()954			.into_iter()955			.map(|(k, d)| {956				(957					k,958					d.exists_visible.expect("non-existing fields filtered out"),959				)960			})961			.collect();962		fields.sort_unstable_by(|a, b| a.0.cmp(&b.0));963		fields964	}965	pub fn fields_ex(966		&self,967		include_hidden: bool,968		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,969	) -> Vec<IStr> {970		#[cfg(feature = "exp-preserve-order")]971		if preserve_order {972			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self973				.fields_visibility()974				.into_iter()975				.filter(|(_, d)| include_hidden || d.visible())976				.enumerate()977				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))978				.unzip();979			keys.sort_unstable_by_key(|v| v.0);980			// Reorder in-place by resulting indexes981			for i in 0..fields.len() {982				let x = fields[i].clone();983				let mut j = i;984				loop {985					let k = keys[j].1;986					keys[j].1 = j;987					if k == i {988						break;989					}990					fields[j] = fields[k].clone();991					j = k;992				}993				fields[j] = x;994			}995			return fields;996		}997998		let mut fields: Vec<_> = self999			.fields_visibility()1000			.into_iter()1001			.filter(|(_, d)| include_hidden || d.visible())1002			.map(|(k, _)| k)1003			.collect();1004		fields.sort_unstable();1005		fields1006	}1007	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {1008		self.fields_ex(1009			false,1010			#[cfg(feature = "exp-preserve-order")]1011			preserve_order,1012		)1013	}1014	pub fn values_ex(1015		&self,1016		include_hidden: bool,1017		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,1018	) -> ArrValue {1019		ArrValue::new(PickObjectValues::new(1020			self.clone(),1021			self.fields_ex(1022				include_hidden,1023				#[cfg(feature = "exp-preserve-order")]1024				preserve_order,1025			),1026		))1027	}1028	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {1029		self.values_ex(1030			false,1031			#[cfg(feature = "exp-preserve-order")]1032			preserve_order,1033		)1034	}1035	pub fn key_values_ex(1036		&self,1037		include_hidden: bool,1038		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,1039	) -> ArrValue {1040		ArrValue::new(PickObjectKeyValues::new(1041			self.clone(),1042			self.fields_ex(1043				include_hidden,1044				#[cfg(feature = "exp-preserve-order")]1045				preserve_order,1046			),1047		))1048	}1049	pub fn key_values(1050		&self,1051		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,1052	) -> ArrValue {1053		self.key_values_ex(1054			false,1055			#[cfg(feature = "exp-preserve-order")]1056			preserve_order,1057		)1058	}1059}10601061#[allow(clippy::module_name_repetitions)]1062#[must_use = "value not added unless binding() was called"]1063pub struct ObjMemberBuilder<Kind> {1064	kind: Kind,1065	name: IStr,1066	add: bool,1067	visibility: Visibility,1068	original_index: FieldIndex,1069	location: Option<Span>,1070}10711072#[allow(clippy::missing_const_for_fn)]1073impl<Kind> ObjMemberBuilder<Kind> {1074	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {1075		Self {1076			kind,1077			name,1078			original_index,1079			add: false,1080			visibility: Visibility::Normal,1081			location: None,1082		}1083	}10841085	pub const fn with_add(mut self, add: bool) -> Self {1086		self.add = add;1087		self1088	}1089	pub fn add(self) -> Self {1090		self.with_add(true)1091	}1092	pub fn with_visibility(mut self, visibility: Visibility) -> Self {1093		self.visibility = visibility;1094		self1095	}1096	pub fn hide(self) -> Self {1097		self.with_visibility(Visibility::Hidden)1098	}1099	pub fn with_location(mut self, location: Span) -> Self {1100		self.location = Some(location);1101		self1102	}1103	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, FieldIndex, ObjMember) {1104		(1105			self.kind,1106			self.name,1107			self.original_index,1108			ObjMember {1109				flags: ObjFieldFlags::new(self.add, self.visibility),1110				invoke: binding,1111				location: self.location,1112			},1113		)1114	}1115}11161117pub struct ExtendBuilder<'v>(&'v mut ObjValue);1118impl ObjMemberBuilder<ExtendBuilder<'_>> {1119	pub fn value(self, value: impl Into<Val>) {1120		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1121	}1122	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1123		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1124	}1125	pub fn binding(self, binding: MaybeUnbound) {1126		let (receiver, name, _, member) = self.build_member(binding);1127		let new = receiver.0.clone();1128		*receiver.0 = new.extend_with_raw_member(name, member);1129	}1130}