diff --git a/gen/build/src/cargo.rs b/gen/build/src/cargo.rs
index cbaa58a4..224f441a 100644
--- a/gen/build/src/cargo.rs
+++ b/gen/build/src/cargo.rs
@@ -51,13 +51,11 @@ impl CargoEnv {
         let mut features = Set::new();
         let mut cfgs = Map::new();
         for (k, v) in env::vars_os() {
-            let k = match k.to_str() {
-                Some(k) => k,
-                None => continue,
+            let Some(k) = k.to_str() else {
+                continue;
             };
-            let v = match v.into_string() {
-                Ok(v) => v,
-                Err(_) => continue,
+            let Ok(v) = v.into_string() else {
+                continue;
             };
             if let Some(feature_name) = k.strip_prefix(CARGO_FEATURE_PREFIX) {
                 let feature_name = Name(feature_name.to_owned());
diff --git a/gen/build/src/lib.rs b/gen/build/src/lib.rs
index ef8aeaf1..16ea0e3e 100644
--- a/gen/build/src/lib.rs
+++ b/gen/build/src/lib.rs
@@ -58,7 +58,6 @@
     clippy::inherent_to_string,
     clippy::into_iter_without_iter,
     clippy::items_after_statements,
-    clippy::manual_let_else,
     clippy::match_bool,
     clippy::match_on_vec_items,
     clippy::match_same_arms,
@@ -435,9 +434,8 @@ fn best_effort_copy_headers(src: &Path, dst: &Path, max_depth: usize) {
     use std::fs;
 
     let mut dst_created = false;
-    let mut entries = match fs::read_dir(src) {
-        Ok(entries) => entries,
-        Err(_) => return,
+    let Ok(mut entries) = fs::read_dir(src) else {
+        return;
     };
 
     while let Some(Ok(entry)) = entries.next() {
diff --git a/gen/build/src/out.rs b/gen/build/src/out.rs
index 0095666f..757105c0 100644
--- a/gen/build/src/out.rs
+++ b/gen/build/src/out.rs
@@ -157,9 +157,8 @@ fn best_effort_relativize_symlink(original: impl AsRef<Path>, link: impl AsRef<P
     let original = original.as_ref();
     let link = link.as_ref();
 
-    let relative_path = match abstractly_relativize_symlink(original, link) {
-        Some(relative_path) => relative_path,
-        None => return original.to_path_buf(),
+    let Some(relative_path) = abstractly_relativize_symlink(original, link) else {
+        return original.to_path_buf();
     };
 
     // Sometimes "a/b/../c" refers to a different canonical location than "a/c".
diff --git a/gen/lib/src/lib.rs b/gen/lib/src/lib.rs
index d78f8a22..e9e30e99 100644
--- a/gen/lib/src/lib.rs
+++ b/gen/lib/src/lib.rs
@@ -20,7 +20,6 @@
     clippy::inherent_to_string,
     clippy::into_iter_without_iter,
     clippy::items_after_statements,
-    clippy::manual_let_else,
     clippy::match_bool,
     clippy::match_on_vec_items,
     clippy::match_same_arms,
diff --git a/macro/src/lib.rs b/macro/src/lib.rs
index 50c30999..472dbc4c 100644
--- a/macro/src/lib.rs
+++ b/macro/src/lib.rs
@@ -9,7 +9,6 @@
     clippy::into_iter_without_iter,
     clippy::items_after_statements,
     clippy::large_enum_variant,
-    clippy::manual_let_else,
     clippy::match_bool,
     clippy::match_same_arms,
     clippy::module_name_repetitions,
diff --git a/syntax/check.rs b/syntax/check.rs
index b5fd45e1..39ee0b0a 100644
--- a/syntax/check.rs
+++ b/syntax/check.rs
@@ -555,9 +555,8 @@ fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) {
         if receiver.mutable {
             return;
         }
-        let resolve = match cx.types.try_resolve(&receiver.ty) {
-            Some(resolve) => resolve,
-            None => return,
+        let Some(resolve) = cx.types.try_resolve(&receiver.ty) else {
+            return;
         };
         if !resolve.generics.lifetimes.is_empty() {
             return;
diff --git a/syntax/parse.rs b/syntax/parse.rs
index 850dcc8d..4d266a9a 100644
--- a/syntax/parse.rs
+++ b/syntax/parse.rs
@@ -436,14 +436,11 @@ fn parse_foreign_mod(
 }
 
 fn parse_lang(abi: &Abi) -> Result<Lang> {
-    let name = match &abi.name {
-        Some(name) => name,
-        None => {
-            return Err(Error::new_spanned(
-                abi,
-                "ABI name is required, extern \"C++\" or extern \"Rust\"",
-            ));
-        }
+    let Some(name) = &abi.name else {
+        return Err(Error::new_spanned(
+            abi,
+            "ABI name is required, extern \"C++\" or extern \"Rust\"",
+        ));
     };
 
     match name.value().as_str() {
@@ -1329,16 +1326,12 @@ fn parse_type_path(ty: &TypePath) -> Result<Type> {
 fn parse_type_array(ty: &TypeArray) -> Result<Type> {
     let inner = parse_type(&ty.elem)?;
 
-    let len_expr = if let Expr::Lit(lit) = &ty.len {
-        lit
-    } else {
+    let Expr::Lit(len_expr) = &ty.len else {
         let msg = "unsupported expression, array length must be an integer literal";
         return Err(Error::new_spanned(&ty.len, msg));
     };
 
-    let len_token = if let Lit::Int(int) = &len_expr.lit {
-        int.clone()
-    } else {
+    let Lit::Int(len_token) = &len_expr.lit else {
         let msg = "array length must be an integer literal";
         return Err(Error::new_spanned(len_expr, msg));
     };
@@ -1357,7 +1350,7 @@ fn parse_type_array(ty: &TypeArray) -> Result<Type> {
         inner,
         semi_token,
         len,
-        len_token,
+        len_token: len_token.clone(),
     })))
 }
 
diff --git a/syntax/report.rs b/syntax/report.rs
index 1997182a..4cdedd00 100644
--- a/syntax/report.rs
+++ b/syntax/report.rs
@@ -21,9 +21,8 @@ impl Errors {
 
     pub(crate) fn propagate(&mut self) -> Result<()> {
         let mut iter = self.errors.drain(..);
-        let mut all_errors = match iter.next() {
-            Some(err) => err,
-            None => return Ok(()),
+        let Some(mut all_errors) = iter.next() else {
+            return Ok(());
         };
         for err in iter {
             all_errors.combine(err);
diff --git a/syntax/types.rs b/syntax/types.rs
index 623a8b8d..bc11eb00 100644
--- a/syntax/types.rs
+++ b/syntax/types.rs
@@ -171,9 +171,8 @@ impl<'a> Types<'a> {
         }
 
         for ty in &all {
-            let impl_key = match ty.impl_key() {
-                Some(impl_key) => impl_key,
-                None => continue,
+            let Some(impl_key) = ty.impl_key() else {
+                continue;
             };
             let implicit_impl = match impl_key {
                 ImplKey::RustBox(ident)