git.delta.rocks / jrsonnet / refs/commits / 1ddb92c00d0f

1use std::{collections::BTreeMap, marker::PhantomData, ops::Deref};23use jrsonnet_gcmodule::Trace;4use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_types::{ComplexValType, ValType};67use crate::{8	arr::{ArrValue, BytesArray},9	bail,10	function::FuncVal,11	typed::CheckType,12	val::{IndexableVal, NumValue, StrValue, ThunkMapper},13	ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val,14};1516#[doc(hidden)]17pub mod __typed_macro_prelude {18	pub use ::jrsonnet_evaluator::{19		error::{ErrorKind, Result as JrResult},20		typed::{21			CheckType, ComplexValType, FromUntyped, IntoUntyped, ParseTypedObj, SerializeTypedObj,22			Typed,23		},24		IStr, ObjValue, ObjValueBuilder, State, Val,25	};26}27pub use jrsonnet_macros::{FromUntyped, IntoUntyped, Typed};2829#[derive(Trace)]30struct ThunkFromUntyped<K: Trace>(PhantomData<fn() -> K>);31impl<K> ThunkMapper<Val> for ThunkFromUntyped<K>32where33	K: Typed + FromUntyped + Trace,34{35	type Output = K;3637	fn map(self, from: Val) -> Result<Self::Output> {38		K::from_untyped(from)39	}40}41impl<K: Trace> Default for ThunkFromUntyped<K> {42	fn default() -> Self {43		Self(PhantomData)44	}45}46#[derive(Trace)]47struct ThunkIntoUntyped<K: Trace>(PhantomData<fn() -> K>);48impl<K> ThunkMapper<K> for ThunkIntoUntyped<K>49where50	K: Typed + Trace + IntoUntyped,51{52	type Output = Val;5354	fn map(self, from: K) -> Result<Self::Output> {55		K::into_untyped(from)56	}57}58impl<K: Trace> Default for ThunkIntoUntyped<K> {59	fn default() -> Self {60		Self(PhantomData)61	}62}6364#[diagnostic::on_unimplemented(65	note = "don't implement `ParseTypedObj` directly, it is automatically provided by `FromUntyped` derive"66)]67pub trait ParseTypedObj: Typed {68	fn parse(obj: &ObjValue) -> Result<Self>;69}7071#[diagnostic::on_unimplemented(72	note = "don't implement `SerializeTypedObj` directly, it is automatically provided by `IntoUntyped` derive"73)]74pub trait SerializeTypedObj: Typed {75	fn serialize(self, out: &mut ObjValueBuilder) -> Result<()>;76	fn into_object(self) -> Result<ObjValue> {77		let mut builder = ObjValueBuilder::new();78		self.serialize(&mut builder)?;79		Ok(builder.build())80	}81}8283pub trait Typed: Sized {84	const TYPE: &'static ComplexValType;85}86pub trait IntoUntyped: Typed {87	// Whatever caller should use `into_lazy_untyped` instead of `into_untyped`88	fn provides_lazy() -> bool {89		false90	}91	fn into_untyped(typed: Self) -> Result<Val>;92	fn into_lazy_untyped(typed: Self) -> Thunk<Val> {93		Thunk::from(Self::into_untyped(typed))94	}95}96pub trait IntoUntypedResult: Typed {97	/// Hack to make builtins be able to return non-result values, and make macros able to convert those values to result98	/// This method returns identity in impl Typed for Result, and should not be overriden99	#[doc(hidden)]100	fn into_untyped_result(typed: Self) -> Result<Val>;101}102impl<T> IntoUntypedResult for T103where104	T: IntoUntyped,105{106	fn into_untyped_result(typed: Self) -> Result<Val> {107		T::into_untyped(typed)108	}109}110111pub trait FromUntyped: Typed {112	fn from_untyped(untyped: Val) -> Result<Self>;113	fn from_lazy_untyped(lazy: Thunk<Val>) -> Result<Self> {114		Self::from_untyped(lazy.evaluate()?)115	}116117	// Whatever caller should use `from_lazy_untyped` instead of `from_untyped` when possible118	fn wants_lazy() -> bool {119		false120	}121}122123impl<T> Typed for Thunk<T>124where125	T: Typed + Trace + Clone,126{127	const TYPE: &'static ComplexValType = &ComplexValType::Lazy(T::TYPE);128}129130impl<T> IntoUntyped for Thunk<T>131where132	T: Typed + IntoUntyped + Trace + Clone,133{134	fn into_untyped(typed: Self) -> Result<Val> {135		T::into_untyped(typed.evaluate()?)136	}137	fn provides_lazy() -> bool {138		true139	}140141	fn into_lazy_untyped(inner: Self) -> Thunk<Val> {142		inner.map(<ThunkIntoUntyped<T>>::default())143	}144}145146impl<T> FromUntyped for Thunk<T>147where148	T: Typed + FromUntyped + Trace + Clone,149{150	fn from_untyped(untyped: Val) -> Result<Self> {151		Self::from_lazy_untyped(Thunk::evaluated(untyped))152	}153154	fn wants_lazy() -> bool {155		true156	}157158	fn from_lazy_untyped(inner: Thunk<Val>) -> Result<Self> {159		Ok(inner.map(<ThunkFromUntyped<T>>::default()))160	}161}162163pub const MAX_SAFE_INTEGER: f64 = ((1u64 << (f64::MANTISSA_DIGITS)) - 1) as f64;164pub const MIN_SAFE_INTEGER: f64 = (-((1i64 << (f64::MANTISSA_DIGITS)) - 1)) as f64;165166macro_rules! impl_int {167	($($ty:ty)*) => {$(168		impl Typed for $ty {169			const TYPE: &'static ComplexValType =170				&ComplexValType::BoundedNumber(Some(Self::MIN as f64), Some(Self::MAX as f64));171		}172		impl FromUntyped for $ty {173			fn from_untyped(value: Val) -> Result<Self> {174				<Self as Typed>::TYPE.check(&value)?;175				match value {176					Val::Num(n) => {177						let n = n.get();178						#[allow(clippy::float_cmp)]179						if n.trunc() != n {180							bail!(181								"cannot convert number with fractional part to {}",182								stringify!($ty)183							)184						}185						Ok(n as Self)186					}187					_ => unreachable!(),188				}189			}190		}191		impl IntoUntyped for $ty {192			fn into_untyped(value: Self) -> Result<Val> {193				Ok(Val::Num(value.into()))194			}195		}196	)*};197}198199impl_int!(i8 u8 i16 u16 i32 u32);200201macro_rules! impl_bounded_int {202	($($name:ident = $ty:ty)*) => {$(203		#[derive(Clone, Copy)]204		pub struct $name<const MIN: $ty, const MAX: $ty>($ty);205		impl<const MIN: $ty, const MAX: $ty> $name<MIN, MAX> {206			pub const fn new(value: $ty) -> Option<$name<MIN, MAX>> {207				if value >= MIN && value <= MAX {208					Some(Self(value))209				} else {210					None211				}212			}213			pub const fn value(self) -> $ty {214				self.0215			}216		}217		impl<const MIN: $ty, const MAX: $ty> Deref for $name<MIN, MAX> {218			type Target = $ty;219			fn deref(&self) -> &Self::Target {220				&self.0221			}222		}223224		impl<const MIN: $ty, const MAX: $ty> Typed for $name<MIN, MAX> {225			const TYPE: &'static ComplexValType =226				&ComplexValType::BoundedNumber(227					Some(MIN as f64),228					Some(MAX as f64),229				);230		}231232		impl<const MIN: $ty, const MAX: $ty> FromUntyped for $name<MIN, MAX> {233			fn from_untyped(value: Val) -> Result<Self> {234				<Self as Typed>::TYPE.check(&value)?;235				match value {236					Val::Num(n) => {237						let n = n.get();238						#[allow(clippy::float_cmp)]239						if n.trunc() != n {240							bail!(241								"cannot convert number with fractional part to {}",242								stringify!($ty)243							)244						}245						Ok(Self(n as $ty))246					}247					_ => unreachable!(),248				}249			}250		}251252		impl<const MIN: $ty, const MAX: $ty> IntoUntyped for $name<MIN, MAX> {253			#[allow(clippy::cast_lossless)]254			fn into_untyped(value: Self) -> Result<Val> {255				Ok(Val::try_num(value.0)?)256			}257		}258	)*};259}260261impl_bounded_int!(262	BoundedI8 = i8263	BoundedI16 = i16264	BoundedI32 = i32265	BoundedI64 = i64266	BoundedUsize = usize267);268269impl Typed for f64 {270	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);271}272impl IntoUntyped for f64 {273	fn into_untyped(value: Self) -> Result<Val> {274		Ok(Val::try_num(value)?)275	}276}277impl FromUntyped for f64 {278	fn from_untyped(value: Val) -> Result<Self> {279		<Self as Typed>::TYPE.check(&value)?;280		match value {281			Val::Num(n) => Ok(n.get()),282			_ => unreachable!(),283		}284	}285}286287pub struct PositiveF64(pub f64);288impl Typed for PositiveF64 {289	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(0.0), None);290}291impl IntoUntyped for PositiveF64 {292	fn into_untyped(value: Self) -> Result<Val> {293		Ok(Val::try_num(value.0)?)294	}295}296impl FromUntyped for PositiveF64 {297	fn from_untyped(value: Val) -> Result<Self> {298		<Self as Typed>::TYPE.check(&value)?;299		match value {300			Val::Num(n) => Ok(Self(n.get())),301			_ => unreachable!(),302		}303	}304}305impl Typed for usize {306	const TYPE: &'static ComplexValType =307		&ComplexValType::BoundedNumber(Some(0.0), Some(MAX_SAFE_INTEGER));308}309impl IntoUntyped for usize {310	fn into_untyped(value: Self) -> Result<Val> {311		Ok(Val::try_num(value)?)312	}313}314impl FromUntyped for usize {315	fn from_untyped(value: Val) -> Result<Self> {316		<Self as Typed>::TYPE.check(&value)?;317		match value {318			Val::Num(n) => {319				let n = n.get();320				#[allow(clippy::float_cmp)]321				if n.trunc() != n {322					bail!("cannot convert number with fractional part to usize")323				}324				Ok(n as Self)325			}326			_ => unreachable!(),327		}328	}329}330331impl Typed for IStr {332	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);333}334impl IntoUntyped for IStr {335	fn into_untyped(value: Self) -> Result<Val> {336		Ok(Val::string(value))337	}338}339impl FromUntyped for IStr {340	fn from_untyped(value: Val) -> Result<Self> {341		<Self as Typed>::TYPE.check(&value)?;342		match value {343			Val::Str(s) => Ok(s.into_flat()),344			_ => unreachable!(),345		}346	}347}348349impl Typed for String {350	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);351}352impl IntoUntyped for String {353	fn into_untyped(value: Self) -> Result<Val> {354		Ok(Val::string(value))355	}356}357impl FromUntyped for String {358	fn from_untyped(value: Val) -> Result<Self> {359		<Self as Typed>::TYPE.check(&value)?;360		match value {361			Val::Str(s) => Ok(s.to_string()),362			_ => unreachable!(),363		}364	}365}366367impl Typed for StrValue {368	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Str);369}370impl IntoUntyped for StrValue {371	fn into_untyped(value: Self) -> Result<Val> {372		Ok(Val::Str(value))373	}374}375impl FromUntyped for StrValue {376	fn from_untyped(value: Val) -> Result<Self> {377		<Self as Typed>::TYPE.check(&value)?;378		match value {379			Val::Str(s) => Ok(s),380			_ => unreachable!(),381		}382	}383}384385impl Typed for char {386	const TYPE: &'static ComplexValType = &ComplexValType::Char;387}388impl IntoUntyped for char {389	fn into_untyped(value: Self) -> Result<Val> {390		Ok(Val::string(value))391	}392}393impl FromUntyped for char {394	fn from_untyped(value: Val) -> Result<Self> {395		<Self as Typed>::TYPE.check(&value)?;396		match value {397			Val::Str(s) => Ok(s.into_flat().chars().next().unwrap()),398			_ => unreachable!(),399		}400	}401}402403// TODO: View into vec using ArrayLike?404impl<T> Typed for Vec<T>405where406	T: Typed,407{408	const TYPE: &'static ComplexValType = &ComplexValType::ArrayRef(T::TYPE);409}410impl<T: Typed + IntoUntyped> IntoUntyped for Vec<T> {411	fn into_untyped(value: Self) -> Result<Val> {412		Ok(Val::Arr(413			value414				.into_iter()415				.map(T::into_untyped)416				.collect::<Result<ArrValue>>()?,417		))418	}419}420impl<T: Typed + FromUntyped> FromUntyped for Vec<T> {421	fn from_untyped(value: Val) -> Result<Self> {422		let Val::Arr(a) = value else {423			<Self as Typed>::TYPE.check(&value)?;424			unreachable!("typecheck should fail")425		};426		a.iter()427			.enumerate()428			.map(|(i, r)| {429				r.and_then(|t| {430					T::from_untyped(t).with_description(|| format!("parsing elem <{i}>"))431				})432			})433			.collect::<Result<Self>>()434	}435}436437// TODO: View into BTreeMap using ObjectCore?438impl<K, V> Typed for BTreeMap<K, V>439where440	K: Typed + Ord,441	V: Typed,442{443	const TYPE: &'static ComplexValType = &ComplexValType::AttrsOf(V::TYPE);444}445impl<K, V> IntoUntyped for BTreeMap<K, V>446where447	K: Typed + Ord + IntoUntyped,448	V: Typed + IntoUntyped,449{450	fn into_untyped(typed: Self) -> Result<Val> {451		let mut out = ObjValueBuilder::with_capacity(typed.len());452		for (k, v) in typed {453			let Some(key) = K::into_untyped(k)?.as_str() else {454				bail!("map key should serialize to string");455			};456			let value = V::into_untyped(v)?;457			out.field(key).value(value);458		}459		Ok(Val::Obj(out.build()))460	}461}462impl<K, V> FromUntyped for BTreeMap<K, V>463where464	K: FromUntyped + Ord,465	V: FromUntyped,466{467	fn from_untyped(value: Val) -> Result<Self> {468		Self::TYPE.check(&value)?;469		let obj = value.as_obj().expect("typecheck should fail");470471		let mut out = Self::new();472		if V::wants_lazy() {473			for key in obj.fields_ex(474				false,475				#[cfg(feature = "exp-preserve-order")]476				false,477			) {478				let value = obj.get_lazy(key.clone()).expect("field exists");479				let value = V::from_lazy_untyped(value)?;480				let key = K::from_untyped(Val::Str(key.into()))?;481				let _ = out.insert(key, value);482			}483		} else {484			for (key, value) in obj.iter(485				#[cfg(feature = "exp-preserve-order")]486				false,487			) {488				let key = K::from_untyped(Val::Str(key.into()))?;489				let value = V::from_untyped(value?)?;490				let _ = out.insert(key, value);491			}492		}493		Ok(out)494	}495}496497impl Typed for Val {498	const TYPE: &'static ComplexValType = &ComplexValType::Any;499}500impl IntoUntyped for Val {501	fn into_untyped(typed: Self) -> Result<Val> {502		Ok(typed)503	}504}505impl FromUntyped for Val {506	fn from_untyped(untyped: Val) -> Result<Self> {507		Ok(untyped)508	}509}510511#[doc(hidden)]512impl<T> Typed for Result<T>513where514	T: Typed,515{516	const TYPE: &'static ComplexValType = &ComplexValType::Any;517}518impl<T: IntoUntyped> IntoUntypedResult for Result<T> {519	fn into_untyped_result(typed: Self) -> Result<Val> {520		typed.map(T::into_untyped)?521	}522}523524/// Specialization525impl Typed for IBytes {526	const TYPE: &'static ComplexValType =527		&ComplexValType::ArrayRef(&ComplexValType::BoundedNumber(Some(0.0), Some(255.0)));528}529impl IntoUntyped for IBytes {530	fn into_untyped(value: Self) -> Result<Val> {531		Ok(Val::Arr(ArrValue::bytes(value)))532	}533}534impl FromUntyped for IBytes {535	fn from_untyped(value: Val) -> Result<Self> {536		let Val::Arr(a) = &value else {537			<Self as Typed>::TYPE.check(&value)?;538			unreachable!()539		};540		if let Some(bytes) = a.as_any().downcast_ref::<BytesArray>() {541			return Ok(bytes.0.as_slice().into());542		}543		<Self as Typed>::TYPE.check(&value)?;544		// Any::downcast_ref::<ByteArray>(&a);545		let mut out = Vec::with_capacity(a.len());546		for e in a.iter() {547			let r = e?;548			out.push(u8::from_untyped(r)?);549		}550		Ok(out.as_slice().into())551	}552}553554pub struct M1;555impl Typed for M1 {556	const TYPE: &'static ComplexValType = &ComplexValType::BoundedNumber(Some(-1.0), Some(-1.0));557}558impl IntoUntyped for M1 {559	fn into_untyped(_: Self) -> Result<Val> {560		Ok(Val::Num(NumValue::new(-1.0).expect("finite")))561	}562}563impl FromUntyped for M1 {564	fn from_untyped(value: Val) -> Result<Self> {565		<Self as Typed>::TYPE.check(&value)?;566		Ok(Self)567	}568}569570macro_rules! decl_either {571	($($name: ident, $($id: ident)*);*) => {$(572		#[derive(Clone)]573		pub enum $name<$($id),*> {574			$($id($id)),*575		}576		impl<$($id),*> Typed for $name<$($id),*>577		where578			$($id: Typed,)*579		{580			const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[$($id::TYPE),*]);581		}582		impl<$($id),*> IntoUntyped for $name<$($id),*>583		where584			$($id: Typed + IntoUntyped,)*585		{586			fn into_untyped(value: Self) -> Result<Val> {587				match value {$(588					$name::$id(v) => $id::into_untyped(v)589				),*}590			}591		}592593		impl<$($id),*> FromUntyped for $name<$($id),*>594		where595			$($id: Typed + FromUntyped,)*596		{597			fn from_untyped(value: Val) -> Result<Self> {598				$(599					if $id::TYPE.check(&value).is_ok() {600						$id::from_untyped(value).map(Self::$id)601					} else602				)* {603					<Self as Typed>::TYPE.check(&value)?;604					unreachable!()605				}606			}607		}608	)*}609}610decl_either!(611	Either1, A;612	Either2, A B;613	Either3, A B C;614	Either4, A B C D;615	Either5, A B C D E;616	Either6, A B C D E F;617	Either7, A B C D E F G618);619#[macro_export]620macro_rules! Either {621	($a:ty) => {$crate::typed::Either1<$a>};622	($a:ty, $b:ty) => {$crate::typed::Either2<$a, $b>};623	($a:ty, $b:ty, $c:ty) => {$crate::typed::Either3<$a, $b, $c>};624	($a:ty, $b:ty, $c:ty, $d:ty) => {$crate::typed::Either4<$a, $b, $c, $d>};625	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty) => {$crate::typed::Either5<$a, $b, $c, $d, $e>};626	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty) => {$crate::typed::Either6<$a, $b, $c, $d, $e, $f>};627	($a:ty, $b:ty, $c:ty, $d:ty, $e:ty, $f:ty, $g:ty) => {$crate::typed::Either7<$a, $b, $c, $d, $e, $f, $g>};628}629pub use Either;630631pub type MyType = Either![u32, f64, String];632633impl Typed for ArrValue {634	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Arr);635}636impl IntoUntyped for ArrValue {637	fn into_untyped(value: Self) -> Result<Val> {638		Ok(Val::Arr(value))639	}640}641impl FromUntyped for ArrValue {642	fn from_untyped(value: Val) -> Result<Self> {643		<Self as Typed>::TYPE.check(&value)?;644		match value {645			Val::Arr(a) => Ok(a),646			_ => unreachable!(),647		}648	}649}650651impl Typed for FuncVal {652	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Func);653}654impl IntoUntyped for FuncVal {655	fn into_untyped(value: Self) -> Result<Val> {656		Ok(Val::Func(value))657	}658}659impl FromUntyped for FuncVal {660	fn from_untyped(value: Val) -> Result<Self> {661		<Self as Typed>::TYPE.check(&value)?;662		match value {663			Val::Func(a) => Ok(a),664			_ => unreachable!(),665		}666	}667}668669impl Typed for ObjValue {670	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Obj);671}672impl IntoUntyped for ObjValue {673	fn into_untyped(value: Self) -> Result<Val> {674		Ok(Val::Obj(value))675	}676}677impl FromUntyped for ObjValue {678	fn from_untyped(value: Val) -> Result<Self> {679		<Self as Typed>::TYPE.check(&value)?;680		match value {681			Val::Obj(a) => Ok(a),682			_ => unreachable!(),683		}684	}685}686687impl Typed for bool {688	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Bool);689}690impl IntoUntyped for bool {691	fn into_untyped(value: Self) -> Result<Val> {692		Ok(Val::Bool(value))693	}694}695impl FromUntyped for bool {696	fn from_untyped(value: Val) -> Result<Self> {697		<Self as Typed>::TYPE.check(&value)?;698		match value {699			Val::Bool(a) => Ok(a),700			_ => unreachable!(),701		}702	}703}704705impl Typed for IndexableVal {706	const TYPE: &'static ComplexValType = &ComplexValType::UnionRef(&[707		&ComplexValType::Simple(ValType::Arr),708		&ComplexValType::Simple(ValType::Str),709	]);710}711impl IntoUntyped for IndexableVal {712	fn into_untyped(value: Self) -> Result<Val> {713		match value {714			Self::Str(s) => Ok(Val::string(s)),715			Self::Arr(a) => Ok(Val::Arr(a)),716		}717	}718}719impl FromUntyped for IndexableVal {720	fn from_untyped(value: Val) -> Result<Self> {721		<Self as Typed>::TYPE.check(&value)?;722		value.into_indexable()723	}724}725726pub struct Null;727impl Typed for Null {728	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Null);729}730impl IntoUntyped for Null {731	fn into_untyped(_: Self) -> Result<Val> {732		Ok(Val::Null)733	}734}735impl FromUntyped for Null {736	fn from_untyped(value: Val) -> Result<Self> {737		<Self as Typed>::TYPE.check(&value)?;738		Ok(Self)739	}740}741742impl<T> Typed for Option<T>743where744	T: Typed,745{746	const TYPE: &'static ComplexValType =747		&ComplexValType::UnionRef(&[&ComplexValType::Simple(ValType::Null), T::TYPE]);748}749impl<T> IntoUntyped for Option<T>750where751	T: Typed + IntoUntyped,752{753	fn into_untyped(typed: Self) -> Result<Val> {754		typed.map_or_else(|| Ok(Val::Null), |v| T::into_untyped(v))755	}756}757impl<T> FromUntyped for Option<T>758where759	T: Typed + FromUntyped,760{761	fn from_untyped(untyped: Val) -> Result<Self> {762		if matches!(untyped, Val::Null) {763			Ok(None)764		} else {765			T::from_untyped(untyped).map(Some)766		}767	}768}769770impl Typed for NumValue {771	const TYPE: &'static ComplexValType = &ComplexValType::Simple(ValType::Num);772}773impl IntoUntyped for NumValue {774	fn into_untyped(typed: Self) -> Result<Val> {775		Ok(Val::Num(typed))776	}777}778impl FromUntyped for NumValue {779	fn from_untyped(untyped: Val) -> Result<Self> {780		Self::TYPE.check(&untyped)?;781		match untyped {782			Val::Num(v) => Ok(v),783			_ => unreachable!(),784		}785	}786}