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) => {

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 {

--- 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"))