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

1use gcmodule::Trace;2use jrsonnet_interner::IStr;3use jrsonnet_parser::{BindSpec, Destruct, LocExpr, ParamsDesc};45use crate::{6	error::{Error::*, Result},7	evaluate, evaluate_method, evaluate_named,8	gc::GcHashMap,9	tb, throw,10	val::ThunkValue,11	Context, Pending, State, Thunk, Val,12};1314#[allow(clippy::too_many_lines)]15#[allow(unused_variables)]16pub fn destruct(17	d: &Destruct,18	parent: Thunk<Val>,19	fctx: Pending<Context>,20	new_bindings: &mut GcHashMap<IStr, Thunk<Val>>,21) -> Result<()> {22	match d {23		Destruct::Full(v) => {24			let old = new_bindings.insert(v.clone(), parent);25			if old.is_some() {26				throw!(DuplicateLocalVar(v.clone()))27			}28		}29		#[cfg(feature = "exp-destruct")]30		Destruct::Skip => {}31		#[cfg(feature = "exp-destruct")]32		Destruct::Array { start, rest, end } => {33			use jrsonnet_parser::DestructRest;3435			use crate::{throw_runtime, val::ArrValue};3637			#[derive(Trace)]38			struct DataThunk {39				parent: Thunk<Val>,40				min_len: usize,41				has_rest: bool,42			}43			impl ThunkValue for DataThunk {44				type Output = ArrValue;4546				fn get(self: Box<Self>, s: State) -> Result<Self::Output> {47					let v = self.parent.evaluate(s)?;48					let arr = match v {49						Val::Arr(a) => a,50						_ => throw_runtime!("expected array"),51					};52					if !self.has_rest {53						if arr.len() != self.min_len {54							throw_runtime!("expected {} elements, got {}", self.min_len, arr.len())55						}56					} else if arr.len() < self.min_len {57						throw_runtime!(58							"expected at least {} elements, but array was only {}",59							self.min_len,60							arr.len()61						)62					}63					Ok(arr)64				}65			}6667			let full = Thunk::new(tb!(DataThunk {68				min_len: start.len() + end.len(),69				has_rest: rest.is_some(),70				parent,71			}));7273			{74				#[derive(Trace)]75				struct BaseThunk {76					full: Thunk<ArrValue>,77					index: usize,78				}79				impl ThunkValue for BaseThunk {80					type Output = Val;8182					fn get(self: Box<Self>, s: State) -> Result<Self::Output> {83						let full = self.full.evaluate(s.clone())?;84						Ok(full.get(s, self.index)?.expect("length is checked"))85					}86				}87				for (i, d) in start.iter().enumerate() {88					destruct(89						d,90						Thunk::new(tb!(BaseThunk {91							full: full.clone(),92							index: i,93						})),94						fctx.clone(),95						new_bindings,96					)?;97				}98			}99100			match rest {101				Some(DestructRest::Keep(v)) => {102					#[derive(Trace)]103					struct RestThunk {104						full: Thunk<ArrValue>,105						start: usize,106						end: usize,107					}108					impl ThunkValue for RestThunk {109						type Output = Val;110111						fn get(self: Box<Self>, s: State) -> Result<Self::Output> {112							let full = self.full.evaluate(s)?;113							let to = full.len() - self.end;114							Ok(Val::Arr(full.slice(Some(self.start), Some(to), None)))115						}116					}117118					destruct(119						&Destruct::Full(v.clone()),120						Thunk::new(tb!(RestThunk {121							full: full.clone(),122							start: start.len(),123							end: end.len(),124						})),125						fctx.clone(),126						new_bindings,127					)?;128				}129				Some(DestructRest::Drop) => {}130				None => {}131			}132133			{134				#[derive(Trace)]135				struct EndThunk {136					full: Thunk<ArrValue>,137					index: usize,138					end: usize,139				}140				impl ThunkValue for EndThunk {141					type Output = Val;142143					fn get(self: Box<Self>, s: State) -> Result<Self::Output> {144						let full = self.full.evaluate(s.clone())?;145						Ok(full146							.get(s, full.len() - self.end + self.index)?147							.expect("length is checked"))148					}149				}150				for (i, d) in end.iter().enumerate() {151					destruct(152						d,153						Thunk::new(tb!(EndThunk {154							full: full.clone(),155							index: i,156							end: end.len(),157						})),158						fctx.clone(),159						new_bindings,160					)?;161				}162			}163		}164		#[cfg(feature = "exp-destruct")]165		Destruct::Object { fields, rest } => {166			use crate::{obj::ObjValue, throw_runtime};167168			#[derive(Trace)]169			struct DataThunk {170				parent: Thunk<Val>,171				field_names: Vec<IStr>,172				has_rest: bool,173			}174			impl ThunkValue for DataThunk {175				type Output = ObjValue;176177				fn get(self: Box<Self>, s: State) -> Result<Self::Output> {178					let v = self.parent.evaluate(s)?;179					let obj = match v {180						Val::Obj(o) => o,181						_ => throw_runtime!("expected object"),182					};183					for field in &self.field_names {184						if !obj.has_field_ex(field.clone(), true) {185							throw_runtime!("missing field: {}", field);186						}187					}188					if !self.has_rest {189						let len = obj.len();190						if len != self.field_names.len() {191							throw_runtime!("too many fields, and rest not found");192						}193					}194					Ok(obj)195				}196			}197			let field_names: Vec<_> = fields198				.iter()199				.filter(|f| f.2.is_none())200				.map(|f| f.0.clone())201				.collect();202			let full = Thunk::new(tb!(DataThunk {203				parent,204				field_names: field_names.clone(),205				has_rest: rest.is_some()206			}));207208			for (field, d, default) in fields {209				#[derive(Trace)]210				struct FieldThunk {211					full: Thunk<ObjValue>,212					field: IStr,213					default: Option<(Pending<Context>, LocExpr)>,214				}215				impl ThunkValue for FieldThunk {216					type Output = Val;217218					fn get(self: Box<Self>, s: State) -> Result<Self::Output> {219						let full = self.full.evaluate(s.clone())?;220						if let Some(field) = full.get(s.clone(), self.field)? {221							Ok(field)222						} else {223							let (fctx, expr) = self.default.as_ref().expect("shape is checked");224							Ok(evaluate(s, fctx.clone().unwrap(), &expr)?)225						}226					}227				}228				let value = Thunk::new(tb!(FieldThunk {229					full: full.clone(),230					field: field.clone(),231					default: default.clone().map(|e| (fctx.clone(), e)),232				}));233				if let Some(d) = d {234					destruct(d, value, fctx.clone(), new_bindings)?;235				} else {236					destruct(237						&Destruct::Full(field.clone()),238						value,239						fctx.clone(),240						new_bindings,241					)?;242				}243			}244		}245	}246	Ok(())247}248249pub fn evaluate_dest(250	d: &BindSpec,251	fctx: Pending<Context>,252	new_bindings: &mut GcHashMap<IStr, Thunk<Val>>,253) -> Result<()> {254	match d {255		BindSpec::Field { into, value } => {256			#[derive(Trace)]257			struct EvaluateThunkValue {258				name: Option<IStr>,259				fctx: Pending<Context>,260				expr: LocExpr,261			}262			impl ThunkValue for EvaluateThunkValue {263				type Output = Val;264				fn get(self: Box<Self>, s: State) -> Result<Self::Output> {265					if let Some(name) = self.name {266						evaluate_named(s, self.fctx.unwrap(), &self.expr, name)267					} else {268						evaluate(s, self.fctx.unwrap(), &self.expr)269					}270				}271			}272			let data = Thunk::new(tb!(EvaluateThunkValue {273				name: into.name(),274				fctx: fctx.clone(),275				expr: value.clone(),276			}));277			destruct(into, data, fctx, new_bindings)?;278		}279		BindSpec::Function {280			name,281			params,282			value,283		} => {284			#[derive(Trace)]285			struct MethodThunk {286				fctx: Pending<Context>,287				name: IStr,288				params: ParamsDesc,289				value: LocExpr,290			}291			impl ThunkValue for MethodThunk {292				type Output = Val;293294				fn get(self: Box<Self>, _s: State) -> Result<Self::Output> {295					Ok(evaluate_method(296						self.fctx.unwrap(),297						self.name,298						self.params,299						self.value,300					))301				}302			}303304			let old = new_bindings.insert(305				name.clone(),306				Thunk::new(tb!(MethodThunk {307					fctx,308					name: name.clone(),309					params: params.clone(),310					value: value.clone()311				})),312			);313			if old.is_some() {314				throw!(DuplicateLocalVar(name.clone()))315			}316		}317	}318	Ok(())319}