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

--- a/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/destructure.rs
@@ -45,9 +45,8 @@
 
 				fn get(self: Box<Self>) -> Result<Self::Output> {
 					let v = self.parent.evaluate()?;
-					let arr = match v {
-						Val::Arr(a) => a,
-						_ => throw!("expected array"),
+					let Val::Arr(arr) = v else {
+						throw!("expected array");
 					};
 					if !self.has_rest {
 						if arr.len() != self.min_len {
@@ -176,9 +175,8 @@
 
 				fn get(self: Box<Self>) -> Result<Self::Output> {
 					let v = self.parent.evaluate()?;
-					let obj = match v {
-						Val::Obj(o) => o,
-						_ => throw!("expected object"),
+					let Val::Obj(obj) = v else {
+						throw!("expected object");
 					};
 					for field in &self.field_names {
 						if !obj.has_field_ex(field.clone(), true) {

--- a/crates/jrsonnet-evaluator/src/evaluate/mod.rs
+++ b/crates/jrsonnet-evaluator/src/evaluate/mod.rs
@@ -162,9 +162,7 @@
 				}
 
 				let name = evaluate_field_name(ctx.clone(), name)?;
-				let name = if let Some(name) = name {
-					name
-				} else {
+				let Some(name) = name else {
 					continue;
 				};
 

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -344,10 +344,10 @@
 		let mut file_cache = self.file_cache();
 		let mut file = file_cache.raw_entry_mut().from_key(&path);
 
-		let file = match file {
-			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
-			RawEntryMut::Vacant(_) => unreachable!("this file was just here!"),
+		let RawEntryMut::Occupied(file) = &mut file else {
+			unreachable!("this file was just here!")
 		};
+		let file = file.get_mut();
 		file.evaluating = false;
 		match res {
 			Ok(v) => {

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -54,12 +54,8 @@
 			ThunkInner::Pending => return Err(InfiniteRecursionDetected.into()),
 			ThunkInner::Waiting(..) => (),
 		};
-		let value = if let ThunkInner::Waiting(value) =
-			std::mem::replace(&mut *self.0.borrow_mut(), ThunkInner::Pending)
-		{
-			value
-		} else {
-			unreachable!()
+		let ThunkInner::Waiting(value) = std::mem::replace(&mut *self.0.borrow_mut(), ThunkInner::Pending) else {
+			unreachable!();
 		};
 		let new_value = match value.0.get() {
 			Ok(v) => v,
@@ -668,9 +664,8 @@
 
 	/// Expects value to be object, outputs (key, manifested value) pairs
 	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(IStr, IStr)>> {
-		let obj = match self {
-			Self::Obj(obj) => obj,
-			_ => throw!(MultiManifestOutputIsNotAObject),
+		let Self::Obj(obj) = self else {
+			throw!(MultiManifestOutputIsNotAObject);
 		};
 		let keys = obj.fields(
 			#[cfg(feature = "exp-preserve-order")]
@@ -689,9 +684,8 @@
 
 	/// Expects value to be array, outputs manifested values
 	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<IStr>> {
-		let arr = match self {
-			Self::Arr(a) => a,
-			_ => throw!(StreamManifestOutputIsNotAArray),
+		let Self::Arr(arr) = self else {
+			throw!(StreamManifestOutputIsNotAArray);
 		};
 		let mut out = Vec::with_capacity(arr.len());
 		for i in arr.iter() {
@@ -703,9 +697,8 @@
 	pub fn manifest(&self, ty: &ManifestFormat) -> Result<IStr> {
 		Ok(match ty {
 			ManifestFormat::YamlStream(format) => {
-				let arr = match self {
-					Self::Arr(a) => a,
-					_ => throw!(StreamManifestOutputIsNotAArray),
+				let Self::Arr(arr) = self else {
+					throw!(StreamManifestOutputIsNotAArray)
 				};
 				let mut out = String::new();
 

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;

--- a/crates/jrsonnet-parser/src/source.rs
+++ b/crates/jrsonnet-parser/src/source.rs
@@ -32,10 +32,8 @@
 			self.hash(&mut hasher)
 		}
 		fn dyn_eq(&self, other: &dyn $T) -> bool {
-			let other = if let Some(v) = other.as_any().downcast_ref::<Self>() {
-				v
-			} else {
-				return false;
+			let Some(other) = other.as_any().downcast_ref::<Self>() else {
+				return false
 			};
 			let this = <Self as $T>::as_any(self)
 				.downcast_ref::<Self>()

--- a/tests/tests/sanity.rs
+++ b/tests/tests/sanity.rs
@@ -22,17 +22,15 @@
 	s.with_stdlib();
 
 	{
-		let e = match s.evaluate_snippet("snip".to_owned(), "assert 1 == 2: 'fail'; null") {
-			Ok(_) => throw!("assertion should fail"),
-			Err(e) => e,
+		let Err(e) = s.evaluate_snippet("snip".to_owned(), "assert 1 == 2: 'fail'; null") else {
+			throw!("assertion should fail");
 		};
 		let e = s.stringify_err(&e);
 		ensure!(e.starts_with("assert failed: fail\n"));
 	}
 	{
-		let e = match s.evaluate_snippet("snip".to_owned(), "std.assertEqual(1, 2)") {
-			Ok(_) => throw!("assertion should fail"),
-			Err(e) => e,
+		let Err(e) = s.evaluate_snippet("snip".to_owned(), "std.assertEqual(1, 2)") else {
+			throw!("assertion should fail")
 		};
 		let e = s.stringify_err(&e);
 		ensure!(e.starts_with("runtime error: Assertion failed. 1 != 2"))