git.delta.rocks / jrsonnet / refs/commits / 8f97cd5c0f83

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	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	original_index: FieldIndex,140	pub invoke: MaybeUnbound,141	pub location: Option<Span>,142}143144cc_dyn!(CcObjectAssertion, ObjectAssertion);145pub trait ObjectAssertion: Trace {146	fn run(&self, sup_this: SupThis) -> Result<()>;147}148149// Field => This150151#[derive(Trace, Debug)]152enum CacheValue {153	Cached(Result<Option<Val>>),154	Pending,155}156157pub type EnumFieldsHandler<'a> =158	dyn FnMut(SuperDepth, FieldIndex, IStr, EnumFields) -> ControlFlow<()> + 'a;159160#[derive(Debug)]161pub 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);237238#[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	/// Create a `SupThis` for a freshly constructed object (no super).402	pub fn new(this: ObjValue) -> Self {403		Self {404			sup: CoreIdx {405				idx: this.0.cores.len(),406			},407			this,408		}409	}410	pub fn has_super(&self) -> bool {411		self.sup.super_exists()412	}413	/// Implementation of `"field" in super` operation,414	/// works faster than standalone super path.415	///416	/// In case of no `super` existence, returns false.417	pub fn field_in_super(&self, field: IStr) -> bool {418		self.this.has_field_include_hidden_idx(field, self.sup)419	}420	/// Implementation of `super.field` operation,421	/// works faster than standalone super path.422	///423	/// In case of no `super` existence, returns `NoSuperFound`424	pub fn get_super(&self, field: IStr) -> Result<Option<Val>> {425		if !self.sup.super_exists() {426			bail!(NoSuperFound);427		}428		self.this.get_idx(field, self.sup)429	}430	/// `super` with `self` overriden for top-level lookups.431	/// Exists when super appears outside of `super.field`/`"field" in super` expressions432	/// Exclusive to jrsonnet.433	///434	/// Might return `NoSuperFound` error.435	pub fn standalone_super(&self) -> Result<ObjValue> {436		if !self.sup.super_exists() {437			bail!(NoSuperFound)438		}439		let mut out = ObjValue::builder();440		out.extend_with_core(StandaloneSuperCore {441			sup: self.sup,442			this: self.this.clone(),443		});444		Ok(out.build())445	}446	pub fn this(&self) -> &ObjValue {447		&self.this448	}449	pub fn downgrade(self) -> WeakSupThis {450		WeakSupThis {451			sup: self.sup,452			this: self.this.downgrade(),453		}454	}455}456#[derive(Trace, PartialEq, Eq, Hash, Debug)]457pub struct WeakSupThis {458	sup: CoreIdx,459	this: WeakObjValue,460}461462impl ObjValue {463	pub fn builder() -> ObjValueBuilder {464		ObjValueBuilder::new()465	}466	pub fn builder_with_capacity(capacity: usize) -> ObjValueBuilder {467		ObjValueBuilder::with_capacity(capacity)468	}469	pub(crate) fn extend_with_raw_member(self, key: IStr, value: ObjMember) -> Self {470		let mut out = ObjValueBuilder::with_capacity(1);471		out.with_super(self);472		let mut member = out.field(key);473		if value.flags.add() {474			member = member.add();475		}476		if let Some(loc) = value.location {477			member = member.with_location(loc);478		}479		let _ = member480			.with_visibility(value.flags.visibility())481			.binding(value.invoke);482		out.build()483	}484	pub fn extend_field(&mut self, name: IStr) -> ObjMemberBuilder<ExtendBuilder<'_>> {485		ObjMemberBuilder::new(ExtendBuilder(self), name, FieldIndex::default())486	}487488	pub fn extend(&mut self) -> ObjValueBuilder {489		let mut out = ObjValueBuilder::new();490		out.with_super(self.clone());491		out492	}493494	#[must_use]495	pub fn extend_from(&self, sup: Self) -> Self {496		let mut cores = Vec::with_capacity(sup.0.cores.len() + self.0.cores.len());497		cores.extend(sup.0.cores.iter().cloned());498		cores.extend(self.0.cores.iter().cloned());499500		let has_assertions = sup.0.has_assertions || self.0.has_assertions;501		ObjValue(Cc::new(ObjValueInner {502			cores,503			value_cache: RefCell::default(),504			assertions_ran: Cell::new(!has_assertions),505			has_assertions,506		}))507	}508	// #[must_use]509	// pub fn with_this(&self, this: Self) -> Self {510	// 	self.0.with_this(self.clone(), this)511	// }512	/// Returns amount of visible object fields513	/// If object only contains hidden fields - may return zero.514	pub fn len(&self) -> u32 {515		self.fields_visibility()516			.values()517			.filter(|d| d.visible())518			.count() as u32519	}520	/// For each field, calls callback.521	/// If callback returns false - ends iteration prematurely.522	///523	/// Returns false if ended prematurely524	pub fn enum_fields(&self, handler: &mut EnumFieldsHandler<'_>) -> bool {525		let mut super_depth = SuperDepth::default();526		self.enum_fields_idx(527			&mut super_depth,528			handler,529			CoreIdx {530				idx: self.0.cores.len(),531			},532		)533	}534535	fn iter_cores(&self, idx: CoreIdx) -> impl Iterator<Item = &CcObjectCore> {536		self.0.cores.iter().take(idx.idx).rev()537	}538	fn iter_cores_enumerate(&self, idx: CoreIdx) -> impl Iterator<Item = (CoreIdx, &CcObjectCore)> {539		self.0540			.cores541			.iter()542			.take(idx.idx)543			.enumerate()544			.rev()545			.map(|(idx, o)| (CoreIdx { idx }, o))546	}547548	fn enum_fields_idx(549		&self,550		super_depth: &mut SuperDepth,551		handler: &mut EnumFieldsHandler<'_>,552		idx: CoreIdx,553	) -> bool {554		for core in self.iter_cores(idx) {555			if !core.0.enum_fields_core(super_depth, handler) {556				return false;557			}558			super_depth.deepen();559		}560		true561	}562563	pub fn has_field_include_hidden(&self, name: IStr) -> bool {564		self.has_field_include_hidden_idx(565			name,566			CoreIdx {567				idx: self.0.cores.len(),568			},569		)570	}571	fn has_field_include_hidden_idx(&self, name: IStr, core: CoreIdx) -> bool {572		let mut skip = Saturating(0usize);573		for ele in self.iter_cores(core) {574			match ele.0.has_field_include_hidden_core(name.clone()) {575				HasFieldIncludeHidden::Exists => {576					if skip.0 == 0 {577						return true;578					}579				}580				HasFieldIncludeHidden::Omit(new_skip) => {581					// +1 including this core582					skip = skip.max(new_skip + Saturating(1));583				}584				HasFieldIncludeHidden::NotFound => {}585			}586			skip -= 1;587		}588		false589	}590	pub fn has_field(&self, name: IStr) -> bool {591		match self.field_visibility(name) {592			Some(Visibility::Unhide | Visibility::Normal) => true,593			Some(Visibility::Hidden) | None => false,594		}595	}596	pub fn has_field_ex(&self, name: IStr, include_hidden: bool) -> bool {597		if include_hidden {598			self.has_field_include_hidden(name)599		} else {600			self.has_field(name)601		}602	}603	pub fn get(&self, key: IStr) -> Result<Option<Val>> {604		self.get_idx(605			key,606			CoreIdx {607				idx: self.0.cores.len(),608			},609		)610	}611612	fn get_idx(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {613		let cache_key = (key.clone(), core);614		{615			let mut cache = self.0.value_cache.borrow_mut();616			// entry_ref candidate?617			match cache.entry(cache_key.clone()) {618				Entry::Occupied(v) => match v.get() {619					CacheValue::Cached(v) => return v.clone(),620					CacheValue::Pending => {621						if !is_asserting(self) {622							bail!(InfiniteRecursionDetected);623						}624					}625				},626				Entry::Vacant(v) => {627					v.insert(CacheValue::Pending);628				}629			};630		}631		let result = self.get_idx_uncached(key, core);632		{633			let mut cache = self.0.value_cache.borrow_mut();634			cache.insert(cache_key, CacheValue::Cached(result.clone()));635		}636		result637	}638	fn get_idx_uncached(&self, key: IStr, core: CoreIdx) -> Result<Option<Val>> {639		self.run_assertions()?;640		let mut first_add = None;641		let mut add_stack: Vec<Val> = Vec::new();642		let mut skip = Saturating(0);643		for (sup, core) in self.iter_cores_enumerate(core) {644			let sup_this = SupThis {645				sup,646				this: self.clone(),647			};648			match core.0.get_for_core(key.clone(), sup_this, skip.0 != 0)? {649				GetFor::Final(val) if first_add.is_none() => {650					if skip.0 == 0 {651						return Ok(Some(val));652					}653				}654				GetFor::Final(val) => {655					if skip.0 == 0 {656						add_stack.push(val);657						break;658					}659				}660				GetFor::SuperPlus(val) => {661					if skip.0 == 0 {662						if first_add.is_none() {663							first_add = Some(val);664						} else {665							add_stack.push(val);666						}667					}668				}669				GetFor::Omit(new_skip) => {670					skip = skip.max(new_skip + Saturating(1));671				}672				GetFor::NotFound => {}673			}674			skip -= 1;675		}676		let Some(first) = first_add else {677			if add_stack.is_empty() {678				return Ok(None);679			}680			return Ok(Some(add_stack.pop().expect("single element on stack")));681		};682		if add_stack.is_empty() {683			return Ok(Some(first));684		}685		add_stack.insert(0, first);686		let mut values = add_stack.into_iter().rev();687		let init = values.next().expect("at least 2 elements");688689		values690			.try_fold(init, |a, b| evaluate_add_op(&a, &b))691			.map(Some)692	}693694	pub fn get_or_bail(&self, key: IStr) -> Result<Val> {695		let Some(value) = self.get(key.clone())? else {696			let suggestions = suggest_object_fields(self, key.clone());697			bail!(NoSuchField(key, suggestions))698		};699		Ok(value)700	}701702	fn field_visibility(&self, field: IStr) -> Option<Visibility> {703		self.field_visibility_idx(704			field,705			CoreIdx {706				idx: self.0.cores.len(),707			},708		)709	}710	fn field_visibility_idx(&self, field: IStr, core: CoreIdx) -> Option<Visibility> {711		let mut exists = false;712		let mut skip = Saturating(0usize);713		for ele in self.iter_cores(core) {714			let vis = ele.0.field_visibility_core(field.clone());715			match vis {716				FieldVisibility::Found(vis @ (Visibility::Unhide | Visibility::Hidden)) => {717					if skip.0 == 0 {718						return Some(vis);719					}720				}721				FieldVisibility::Found(Visibility::Normal) => {722					if skip.0 == 0 {723						exists = true;724					}725				}726				FieldVisibility::NotFound => {}727				FieldVisibility::Omit(new_skip) => {728					// +1 including this core729					skip = skip.max(new_skip + Saturating(1));730				}731			}732			skip -= 1;733		}734		exists.then_some(Visibility::Normal)735	}736737	pub fn run_assertions(&self) -> Result<()> {738		if self.0.assertions_ran.get() {739			return Ok(());740		}741		if !start_asserting(self) {742			return Ok(());743		}744		for (idx, ele) in self.0.cores.iter().enumerate() {745			let sup_this = SupThis {746				sup: CoreIdx { idx },747				this: self.clone(),748			};749			ele.0.run_assertions_core(sup_this).inspect_err(|_e| {750				finish_asserting(self);751			})?;752		}753		finish_asserting(self);754		self.0.assertions_ran.set(true);755		Ok(())756	}757758	pub fn iter(759		&self,760		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,761	) -> impl Iterator<Item = (IStr, Result<Val>)> + '_ {762		let fields = self.fields(763			#[cfg(feature = "exp-preserve-order")]764			preserve_order,765		);766		fields.into_iter().map(|field| {767			(768				field.clone(),769				self.get(field)770					.map(|opt| opt.expect("iterating over keys, field exists")),771			)772		})773	}774	pub fn get_lazy(&self, key: IStr) -> Option<Thunk<Val>> {775		#[derive(Trace)]776		struct ObjFieldThunk {777			obj: ObjValue,778			key: IStr,779		}780		impl ThunkValue for ObjFieldThunk {781			type Output = Val;782783			fn get(&self) -> Result<Self::Output> {784				self.obj785					.get(self.key.clone())786					.transpose()787					.expect("field existence checked")788			}789		}790791		if !self.has_field_ex(key.clone(), true) {792			return None;793		}794795		Some(Thunk::new(ObjFieldThunk {796			obj: self.clone(),797			key,798		}))799	}800	pub fn get_lazy_or_bail(&self, key: IStr) -> Thunk<Val> {801		#[derive(Trace)]802		struct ObjFieldThunk {803			obj: ObjValue,804			key: IStr,805		}806		impl ThunkValue for ObjFieldThunk {807			type Output = Val;808809			fn get(&self) -> Result<Self::Output> {810				self.obj.get_or_bail(self.key.clone())811			}812		}813814		Thunk::new(ObjFieldThunk {815			obj: self.clone(),816			key,817		})818	}819820	#[allow(dead_code, reason = "used in object ...rest destructuring")]821	pub(crate) fn as_standalone(&self) -> StandaloneSuperCore {822		StandaloneSuperCore {823			sup: CoreIdx {824				idx: self.0.cores.len(),825			},826			this: self.clone(),827		}828	}829	pub fn ptr_eq(a: &Self, b: &Self) -> bool {830		Cc::ptr_eq(&a.0, &b.0)831	}832	pub fn downgrade(self) -> WeakObjValue {833		WeakObjValue(self.0.downgrade())834	}835}836837#[derive(Debug)]838struct FieldVisibilityData {839	omitted_until: Saturating<usize>,840	exists_visible: Option<Visibility>,841	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]842	key: FieldSortKey,843}844impl FieldVisibilityData {845	fn visible(&self) -> bool {846		self.exists_visible847			.expect("non-existing fields shall be dropped at the end of fn fields_visibility()")848			.is_visible()849	}850	#[allow(dead_code, reason = "used for exp-object-ordering, ZST otherwise")]851	fn sort_key(&self) -> FieldSortKey {852		self.key853	}854}855856impl ObjValue {857	fn fields_visibility(&self) -> FxHashMap<IStr, FieldVisibilityData> {858		let mut out = FxHashMap::default();859860		let mut super_depth = SuperDepth::default();861		let mut omit_index = Saturating(0);862		for core in self.0.cores.iter().rev() {863			core.0864				.enum_fields_core(&mut super_depth, &mut |depth, index, name, visibility| {865					let entry = out.entry(name);866					let data = entry.or_insert_with(|| FieldVisibilityData {867						exists_visible: None,868						key: FieldSortKey::new(depth, index),869						omitted_until: omit_index,870					});871					match visibility {872						EnumFields::Omit(new_skip) => {873							// +1 including this core874							data.omitted_until = data875								.omitted_until876								.max(omit_index + new_skip + Saturating(1));877						}878						EnumFields::Normal(Visibility::Normal) => {879							if data.omitted_until <= omit_index && data.exists_visible.is_none() {880								data.exists_visible = Some(Visibility::Normal);881							}882						}883						EnumFields::Normal(Visibility::Hidden) => {884							if data.omitted_until <= omit_index {885								data.exists_visible = Some(match data.exists_visible {886									// We're iterating in reverse, later unhide is preserved887									Some(Visibility::Unhide) => Visibility::Unhide,888									_ => Visibility::Hidden,889								});890							}891						}892						EnumFields::Normal(Visibility::Unhide) => {893							if data.omitted_until <= omit_index {894								data.exists_visible = Some(match data.exists_visible {895									// We're iterating in reverse, later hide is preserved896									Some(Visibility::Hidden) => Visibility::Hidden,897									_ => Visibility::Unhide,898								});899							}900						}901					}902					ControlFlow::Continue(())903				});904905			super_depth.deepen();906			omit_index += 1;907		}908909		out.retain(|_, v| v.exists_visible.is_some());910911		out912	}913	pub fn fields_ex(914		&self,915		include_hidden: bool,916		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,917	) -> Vec<IStr> {918		#[cfg(feature = "exp-preserve-order")]919		if preserve_order {920			let (mut fields, mut keys): (Vec<_>, Vec<_>) = self921				.fields_visibility()922				.into_iter()923				.filter(|(_, d)| include_hidden || d.visible())924				.enumerate()925				.map(|(idx, (k, d))| (k, (d.sort_key(), idx)))926				.unzip();927			keys.sort_unstable_by_key(|v| v.0);928			// Reorder in-place by resulting indexes929			for i in 0..fields.len() {930				let x = fields[i].clone();931				let mut j = i;932				loop {933					let k = keys[j].1;934					keys[j].1 = j;935					if k == i {936						break;937					}938					fields[j] = fields[k].clone();939					j = k;940				}941				fields[j] = x;942			}943			return fields;944		}945946		let mut fields: Vec<_> = self947			.fields_visibility()948			.into_iter()949			.filter(|(_, d)| include_hidden || d.visible())950			.map(|(k, _)| k)951			.collect();952		fields.sort_unstable();953		fields954	}955	pub fn fields(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> Vec<IStr> {956		self.fields_ex(957			false,958			#[cfg(feature = "exp-preserve-order")]959			preserve_order,960		)961	}962	pub fn values_ex(963		&self,964		include_hidden: bool,965		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,966	) -> ArrValue {967		ArrValue::new(PickObjectValues::new(968			self.clone(),969			self.fields_ex(970				include_hidden,971				#[cfg(feature = "exp-preserve-order")]972				preserve_order,973			),974		))975	}976	pub fn values(&self, #[cfg(feature = "exp-preserve-order")] preserve_order: bool) -> ArrValue {977		self.values_ex(978			false,979			#[cfg(feature = "exp-preserve-order")]980			preserve_order,981		)982	}983	pub fn key_values_ex(984		&self,985		include_hidden: bool,986		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,987	) -> ArrValue {988		ArrValue::new(PickObjectKeyValues::new(989			self.clone(),990			self.fields_ex(991				include_hidden,992				#[cfg(feature = "exp-preserve-order")]993				preserve_order,994			),995		))996	}997	pub fn key_values(998		&self,999		#[cfg(feature = "exp-preserve-order")] preserve_order: bool,1000	) -> ArrValue {1001		self.key_values_ex(1002			false,1003			#[cfg(feature = "exp-preserve-order")]1004			preserve_order,1005		)1006	}1007}10081009#[allow(clippy::module_name_repetitions)]1010#[must_use = "value not added unless binding() was called"]1011pub struct ObjMemberBuilder<Kind> {1012	kind: Kind,1013	name: IStr,1014	add: bool,1015	visibility: Visibility,1016	original_index: FieldIndex,1017	location: Option<Span>,1018}10191020#[allow(clippy::missing_const_for_fn)]1021impl<Kind> ObjMemberBuilder<Kind> {1022	pub(crate) fn new(kind: Kind, name: IStr, original_index: FieldIndex) -> Self {1023		Self {1024			kind,1025			name,1026			original_index,1027			add: false,1028			visibility: Visibility::Normal,1029			location: None,1030		}1031	}10321033	pub const fn with_add(mut self, add: bool) -> Self {1034		self.add = add;1035		self1036	}1037	pub fn add(self) -> Self {1038		self.with_add(true)1039	}1040	pub fn with_visibility(mut self, visibility: Visibility) -> Self {1041		self.visibility = visibility;1042		self1043	}1044	pub fn hide(self) -> Self {1045		self.with_visibility(Visibility::Hidden)1046	}1047	pub fn with_location(mut self, location: Span) -> Self {1048		self.location = Some(location);1049		self1050	}1051	fn build_member(self, binding: MaybeUnbound) -> (Kind, IStr, ObjMember) {1052		(1053			self.kind,1054			self.name,1055			ObjMember {1056				flags: ObjFieldFlags::new(self.add, self.visibility),1057				original_index: self.original_index,1058				invoke: binding,1059				location: self.location,1060			},1061		)1062	}1063}10641065pub struct ExtendBuilder<'v>(&'v mut ObjValue);1066impl ObjMemberBuilder<ExtendBuilder<'_>> {1067	pub fn value(self, value: impl Into<Val>) {1068		self.binding(MaybeUnbound::Bound(Thunk::evaluated(value.into())));1069	}1070	pub fn bindable(self, bindable: impl Unbound<Bound = Val>) {1071		self.binding(MaybeUnbound::Unbound(CcUnbound::new(bindable)));1072	}1073	pub fn binding(self, binding: MaybeUnbound) {1074		let (receiver, name, member) = self.build_member(binding);1075		let new = receiver.0.clone();1076		*receiver.0 = new.extend_with_raw_member(name, member);1077	}1078}