git.delta.rocks / jrsonnet / refs/commits / 1925b3a76ba9

4545
46				fn get(self: Box<Self>) -> Result<Self::Output> {46				fn get(self: Box<Self>) -> Result<Self::Output> {
47					let v = self.parent.evaluate()?;47					let v = self.parent.evaluate()?;
48					let arr = match v {48					let Val::Arr(arr) = v else {
49						Val::Arr(a) => a,
50						_ => throw!("expected array"),49						throw!("expected array");
51					};50					};
52					if !self.has_rest {51					if !self.has_rest {
53						if arr.len() != self.min_len {52						if arr.len() != self.min_len {
54							throw!("expected {} elements, got {}", self.min_len, arr.len())53							throw!("expected {} elements, got {}", self.min_len, arr.len())
176175
177				fn get(self: Box<Self>) -> Result<Self::Output> {176				fn get(self: Box<Self>) -> Result<Self::Output> {
178					let v = self.parent.evaluate()?;177					let v = self.parent.evaluate()?;
179					let obj = match v {178					let Val::Obj(obj) = v else {
180						Val::Obj(o) => o,
181						_ => throw!("expected object"),179						throw!("expected object");
182					};180					};
183					for field in &self.field_names {181					for field in &self.field_names {
184						if !obj.has_field_ex(field.clone(), true) {182						if !obj.has_field_ex(field.clone(), true) {
185							throw!("missing field: {}", field);183							throw!("missing field: {}", field);

162				}162				}
163163
164				let name = evaluate_field_name(ctx.clone(), name)?;164				let name = evaluate_field_name(ctx.clone(), name)?;
165				let name = if let Some(name) = name {165				let Some(name) = name else {
166					name
167				} else {
168					continue;166					continue;
169				};167				};
170168

344		let mut file_cache = self.file_cache();344		let mut file_cache = self.file_cache();
345		let mut file = file_cache.raw_entry_mut().from_key(&path);345		let mut file = file_cache.raw_entry_mut().from_key(&path);
346346
347		let file = match file {347		let RawEntryMut::Occupied(file) = &mut file else {
348			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
349			RawEntryMut::Vacant(_) => unreachable!("this file was just here!"),348			unreachable!("this file was just here!")
350		};349		};
350		let file = file.get_mut();
351		file.evaluating = false;351		file.evaluating = false;
352		match res {352		match res {
353			Ok(v) => {353			Ok(v) => {

54			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),54			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),
55			ThunkInner::Waiting(..) => (),55			ThunkInner::Waiting(..) => (),
56		};56		};
57		let value = if let ThunkInner::Waiting(value) =57		let ThunkInner::Waiting(value) = std::mem::replace(&mut *self.0.borrow_mut(), ThunkInner::Pending) else {
58			std::mem::replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)
59		{
60			value
61		} else {
62			unreachable!()58			unreachable!();
63		};59		};
64		let new_value = match value.0.get() {60		let new_value = match value.0.get() {
65			Ok(v) => v,61			Ok(v) => v,
668664
669	/// Expects value to be object, outputs (key, manifested value) pairs665	/// Expects value to be object, outputs (key, manifested value) pairs
670	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {666	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {
671		let obj = match self {667		let Self::Obj(obj) = self else {
672			Self::Obj(obj) => obj,
673			_ => throw!(MultiManifestOutputIsNotAObject),668			throw!(MultiManifestOutputIsNotAObject);
674		};669		};
675		let keys = obj.fields(670		let keys = obj.fields(
676			#[cfg(feature = "exp-preserve-order")]671			#[cfg(feature = "exp-preserve-order")]
677			ty.preserve_order(),672			ty.preserve_order(),
689684
690	/// Expects value to be array, outputs manifested values685	/// Expects value to be array, outputs manifested values
691	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {686	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {
692		let arr = match self {687		let Self::Arr(arr) = self else {
693			Self::Arr(a) => a,
694			_ => throw!(StreamManifestOutputIsNotAArray),688			throw!(StreamManifestOutputIsNotAArray);
695		};689		};
696		let mut out = Vec::with_capacity(arr.len());690		let mut out = Vec::with_capacity(arr.len());
697		for i in arr.iter() {691		for i in arr.iter() {
698			out.push(i?.manifest(ty)?);692			out.push(i?.manifest(ty)?);
703	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {697	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {
704		Ok(match ty {698		Ok(match ty {
705			ManifestFormat::YamlStream(format) => {699			ManifestFormat::YamlStream(format) => {
706				let arr = match self {700				let Self::Arr(arr) = self else {
707					Self::Arr(a) => a,
708					_ => throw!(StreamManifestOutputIsNotAArray),701					throw!(StreamManifestOutputIsNotAArray)
709				};702				};
710				let mut out = String::new();703				let mut out = String::new();
711704
712				match format as &ManifestFormat {705				match format as &ManifestFormat {

50}50}
5151
52fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {52fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {
53	Ok(if let Some(args) = type_is_path(ty, "Option") {53	let Some(args) = type_is_path(ty, "Option") else {
54		return Ok(None)
55	};
54		// It should have only on angle-bracketed param ("<String>"):56	// It should have only on angle-bracketed param ("<String>"):
55		let generic_arg = match args {57	let PathArguments::AngleBracketed(params) = args else {
56			PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),
57			_ => return Err(Error::new(args.span(), "missing option generic")),58		return Err(Error::new(args.span(), "missing option generic"));
58		};59	};
60	let generic_arg = params.args.iter().next().unwrap();
59		// This argument must be a type:61	// This argument must be a type:
60		match generic_arg {
61			GenericArgument::Type(ty) => Some(ty),62	let GenericArgument::Type(ty) = generic_arg else {
62			_ => {
63				return Err(Error::new(63		return Err(Error::new(
64					generic_arg.span(),64			generic_arg.span(),
65					"option generic should be a type",65			"option generic should be a type",
66				))66		))
67			}67	};
68		}68	Ok(Some(ty))
69	} else {
70		None
71	})
72}69}
7370
74struct Field {71struct Field {
137134
138impl ArgInfo {135impl ArgInfo {
139	fn parse(name: &str, arg: &FnArg) -> Result<Self> {136	fn parse(name: &str, arg: &FnArg) -> Result<Self> {
140		let arg = match arg {137		let FnArg::Typed(arg) = arg else {
141			FnArg::Receiver(_) => unreachable!(),138			unreachable!()
142			FnArg::Typed(a) => a,
143		};139		};
144		let ident = match &arg.pat as &Pat {140		let ident = match &arg.pat as &Pat {
145			Pat::Ident(i) => Some(i.ident.clone()),141			Pat::Ident(i) => Some(i.ident.clone()),
206}202}
207203
208fn builtin_inner(attr: BuiltinAttrs, fun: ItemFn) -> syn::Result<TokenStream> {204fn builtin_inner(attr: BuiltinAttrs, fun: ItemFn) -> syn::Result<TokenStream> {
209	let result = match fun.sig.output {205	let ReturnType::Type(_, result) = &fun.sig.output else {
210		ReturnType::Default => {
211			return Err(Error::new(206		return Err(Error::new(
212				fun.sig.span(),207			fun.sig.span(),
213				"builtin should return something",208			"builtin should return something",
214			))209		))
215		}210	};
211
216		ReturnType::Type(_, ref ty) => ty.clone(),212	let Some(args) = type_is_path(result, "Result") else {
217	};213		return Err(Error::new(result.span(), "return value should be result"));
214
215	};
218	let result_inner = if let Some(args) = type_is_path(&result, "Result") {216	let PathArguments::AngleBracketed(params) = args else {
217		return Err(Error::new(args.span(), "missing result generic"));
218	};
219		let generic_arg = match args {219	let generic_arg = params.args.iter().next().unwrap();
220			PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),
221			_ => return Err(Error::new(args.span(), "missing result generic")),
222		};
223		// This argument must be a type:220	// This argument must be a type:
224		match generic_arg {
225			GenericArgument::Type(ty) => ty,221	let GenericArgument::Type(result_inner) = generic_arg else {
226			_ => {
227				return Err(Error::new(222		return Err(Error::new(
228					generic_arg.span(),223			generic_arg.span(),
229					"option generic should be a type",224			"option generic should be a type",
230				))225		))
231			}226	};
232		}
233	} else {
234		return Err(Error::new(result.span(), "return value should be result"));
235	};
236227
237	let name = fun.sig.ident.to_string();228	let name = fun.sig.ident.to_string();
238	let args = fun229	let args = fun
471impl TypedField {462impl TypedField {
472	fn parse(field: &syn::Field) -> Result<Self> {463	fn parse(field: &syn::Field) -> Result<Self> {
473		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();464		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();
474		let ident = if let Some(ident) = field.ident.clone() {465		let Some(ident) = field.ident.clone() else {
475			ident
476		} else {
477			return Err(Error::new(466			return Err(Error::new(
478				field.span(),467				field.span(),
479				"this field should appear in output object, but it has no visible name",468				"this field should appear in output object, but it has no visible name",
603}592}
604593
605fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {594fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {
606	let data = match &input.data {595	let syn::Data::Struct(data) = &input.data else {
607		syn::Data::Struct(s) => s,
608		_ => return Err(Error::new(input.span(), "only structs supported")),596		return Err(Error::new(input.span(), "only structs supported"));
609	};597	};
610598
611	let ident = &input.ident;599	let ident = &input.ident;

32			self.hash(&mut hasher)32			self.hash(&mut hasher)
33		}33		}
34		fn dyn_eq(&self, other: &dyn $T) -> bool {34		fn dyn_eq(&self, other: &dyn $T) -> bool {
35			let other = if let Some(v) = other.as_any().downcast_ref::<Self>() {35			let Some(other) = other.as_any().downcast_ref::<Self>() else {
36				v
37			} else {
38				return false;36				return false
39			};37			};
40			let this = <Self as $T>::as_any(self)38			let this = <Self as $T>::as_any(self)
41				.downcast_ref::<Self>()39				.downcast_ref::<Self>()

22	s.with_stdlib();22	s.with_stdlib();
2323
24	{24	{
25		let e = match s.evaluate_snippet("snip".to_owned(), "assert 1 == 2: 'fail'; null") {25		let Err(e) = s.evaluate_snippet("snip".to_owned(), "assert 1 == 2: 'fail'; null") else {
26			Ok(_) => throw!("assertion should fail"),26			throw!("assertion should fail");
27			Err(e) => e,
28		};27		};
29		let e = s.stringify_err(&e);28		let e = s.stringify_err(&e);
30		ensure!(e.starts_with("assert failed: fail\n"));29		ensure!(e.starts_with("assert failed: fail\n"));
31	}30	}
32	{31	{
33		let e = match s.evaluate_snippet("snip".to_owned(), "std.assertEqual(1, 2)") {32		let Err(e) = s.evaluate_snippet("snip".to_owned(), "std.assertEqual(1, 2)") else {
34			Ok(_) => throw!("assertion should fail"),33			throw!("assertion should fail")
35			Err(e) => e,
36		};34		};
37		let e = s.stringify_err(&e);35		let e = s.stringify_err(&e);
38		ensure!(e.starts_with("runtime error: Assertion failed. 1 != 2"))36		ensure!(e.starts_with("runtime error: Assertion failed. 1 != 2"))