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

--- 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();
 

--- a/crates/jrsonnet-macros/src/lib.rs
+++ b/crates/jrsonnet-macros/src/lib.rs
@@ -50,25 +50,22 @@
 }
 
 fn extract_type_from_option(ty: &Type) -> Result<Option<&Type>> {
-	Ok(if let Some(args) = type_is_path(ty, "Option") {
-		// It should have only on angle-bracketed param ("<String>"):
-		let generic_arg = match args {
-			PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),
-			_ => return Err(Error::new(args.span(), "missing option generic")),
-		};
-		// This argument must be a type:
-		match generic_arg {
-			GenericArgument::Type(ty) => Some(ty),
-			_ => {
-				return Err(Error::new(
-					generic_arg.span(),
-					"option generic should be a type",
-				))
-			}
-		}
-	} else {
-		None
-	})
+	let Some(args) = type_is_path(ty, "Option") else {
+		return Ok(None)
+	};
+	// It should have only on angle-bracketed param ("<String>"):
+	let PathArguments::AngleBracketed(params) = args else {
+		return Err(Error::new(args.span(), "missing option generic"));
+	};
+	let generic_arg = params.args.iter().next().unwrap();
+	// This argument must be a type:
+	let GenericArgument::Type(ty) = generic_arg else {
+		return Err(Error::new(
+			generic_arg.span(),
+			"option generic should be a type",
+		))
+	};
+	Ok(Some(ty))
 }
 
 struct Field {
@@ -137,9 +134,8 @@
 
 impl ArgInfo {
 	fn parse(name: &str, arg: &FnArg) -> Result<Self> {
-		let arg = match arg {
-			FnArg::Receiver(_) => unreachable!(),
-			FnArg::Typed(a) => a,
+		let FnArg::Typed(arg) = arg else {
+			unreachable!()
 		};
 		let ident = match &arg.pat as &Pat {
 			Pat::Ident(i) => Some(i.ident.clone()),
@@ -206,33 +202,28 @@
 }
 
 fn builtin_inner(attr: BuiltinAttrs, fun: ItemFn) -> syn::Result<TokenStream> {
-	let result = match fun.sig.output {
-		ReturnType::Default => {
-			return Err(Error::new(
-				fun.sig.span(),
-				"builtin should return something",
-			))
-		}
-		ReturnType::Type(_, ref ty) => ty.clone(),
+	let ReturnType::Type(_, result) = &fun.sig.output else {
+		return Err(Error::new(
+			fun.sig.span(),
+			"builtin should return something",
+		))
 	};
-	let result_inner = if let Some(args) = type_is_path(&result, "Result") {
-		let generic_arg = match args {
-			PathArguments::AngleBracketed(params) => params.args.iter().next().unwrap(),
-			_ => return Err(Error::new(args.span(), "missing result generic")),
-		};
-		// This argument must be a type:
-		match generic_arg {
-			GenericArgument::Type(ty) => ty,
-			_ => {
-				return Err(Error::new(
-					generic_arg.span(),
-					"option generic should be a type",
-				))
-			}
-		}
-	} else {
+
+	let Some(args) = type_is_path(result, "Result") else {
 		return Err(Error::new(result.span(), "return value should be result"));
+
+	};
+	let PathArguments::AngleBracketed(params) = args else {
+		return Err(Error::new(args.span(), "missing result generic"));
 	};
+	let generic_arg = params.args.iter().next().unwrap();
+	// This argument must be a type:
+	let GenericArgument::Type(result_inner) = generic_arg else {
+		return Err(Error::new(
+			generic_arg.span(),
+			"option generic should be a type",
+		))
+	};
 
 	let name = fun.sig.ident.to_string();
 	let args = fun
@@ -471,9 +462,7 @@
 impl TypedField {
 	fn parse(field: &syn::Field) -> Result<Self> {
 		let attr = parse_attr::<TypedAttr, _>(&field.attrs, "typed")?.unwrap_or_default();
-		let ident = if let Some(ident) = field.ident.clone() {
-			ident
-		} else {
+		let Some(ident) = field.ident.clone() else {
 			return Err(Error::new(
 				field.span(),
 				"this field should appear in output object, but it has no visible name",
@@ -603,9 +592,8 @@
 }
 
 fn derive_typed_inner(input: DeriveInput) -> Result<TokenStream> {
-	let data = match &input.data {
-		syn::Data::Struct(s) => s,
-		_ => return Err(Error::new(input.span(), "only structs supported")),
+	let syn::Data::Struct(data) = &input.data else {
+		return Err(Error::new(input.span(), "only structs supported"));
 	};
 
 	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"))