Replace with let-chains in pgrx-sql-entity-graph (pgcentralfoundation#2169)

The real reason for pgcentralfoundation#2165

Author: workingjubilee

pgrx-sql-entity-graph/Cargo.toml

@@ -43,4 +43,3 @@ syntect = { version = "5.2.0", default-features = false, features = ["default-fa
 [lints.clippy]
 assigning-clones = "allow" # wrong diagnosis and wrong suggestions
 too-many-arguments = "allow" # I argue with myself all the time
-collapsible-if = "allow" # nuisance in the way of updating editions

pgrx-sql-entity-graph/src/aggregate/mod.rs

@@ -158,20 +158,18 @@ fn extract_generic_from_trait(item_impl: &ItemImpl) -> Result<&Type, syn::Error>
 }
 
 fn get_generic_type_name(ty: &syn::Type) -> Result<String, syn::Error> {
-    if let Type::Path(type_path) = ty {
-        if let Some(ident) = type_path.path.segments.last().map(|s| &s.ident) {
-            let ident = ident.to_string();
-
-            match ident.as_str() {
-                "!" => Ok("never".to_string()),
-                "()" => Ok("unit".to_string()),
-                _ => Ok(ident),
-            }
-        } else {
-            Err(syn::Error::new_spanned(ty, "Generic type path is empty or malformed."))
+    if let Type::Path(type_path) = ty
+        && let Some(ident) = type_path.path.segments.last().map(|s| &s.ident)
+    {
+        let ident = ident.to_string();
+
+        match ident.as_str() {
+            "!" => Ok("never".to_string()),
+            "()" => Ok("unit".to_string()),
+            _ => Ok(ident),
         }
     } else {
-        Err(syn::Error::new_spanned(ty, "Expected a path type for the generic argument."))
+        Err(syn::Error::new_spanned(ty, "Generic type path is empty or malformed."))
     }
 }
 

pgrx-sql-entity-graph/src/pgrx_sql.rs

@@ -522,15 +522,15 @@ fn initialize_extension_sqls(
     }
     for (item, index) in &mapped_extension_sqls {
         graph.add_edge(root, *index, SqlGraphRequires::By);
-        if !item.bootstrap {
-            if let Some(bootstrap) = bootstrap {
-                graph.add_edge(bootstrap, *index, SqlGraphRequires::By);
-            }
+        if !item.bootstrap
+            && let Some(bootstrap) = bootstrap
+        {
+            graph.add_edge(bootstrap, *index, SqlGraphRequires::By);
         }
-        if !item.finalize {
-            if let Some(finalize) = finalize {
-                graph.add_edge(*index, finalize, SqlGraphRequires::By);
-            }
+        if !item.finalize
+            && let Some(finalize) = finalize
+        {
+            graph.add_edge(*index, finalize, SqlGraphRequires::By);
         }
     }
     Ok((mapped_extension_sqls, bootstrap, finalize))

pgrx-sql-entity-graph/src/postgres_type/entity.rs

@@ -82,10 +82,10 @@ impl Alignment {
 
     pub fn from_attributes(attrs: &[Attribute]) -> Result<Self, syn::Error> {
         for attr in attrs {
-            if attr.path().is_ident("pgrx") {
-                if let Some(v) = Self::from_attribute(attr)? {
-                    return Ok(v);
-                }
+            if attr.path().is_ident("pgrx")
+                && let Some(v) = Self::from_attribute(attr)?
+            {
+                return Ok(v);
             }
         }
         Ok(Self::Off)

pgrx-sql-entity-graph/src/used_type.rs

@@ -274,16 +274,13 @@ impl UsedType {
 
         // if the Type is like `Result<T, E>`, this finds the `T`
         let mut resolved_ty_inner: Option<syn::Type> = None;
-        if result {
-            if let syn::Type::Path(tp) = &resolved_ty {
-                if let Some(first_segment) = tp.path.segments.first() {
-                    if let syn::PathArguments::AngleBracketed(ab) = &first_segment.arguments {
-                        if let Some(syn::GenericArgument::Type(ty)) = ab.args.first() {
-                            resolved_ty_inner = Some(ty.clone());
-                        }
-                    }
-                }
-            }
+        if result
+            && let syn::Type::Path(tp) = &resolved_ty
+            && let Some(first_segment) = tp.path.segments.first()
+            && let syn::PathArguments::AngleBracketed(ab) = &first_segment.arguments
+            && let Some(syn::GenericArgument::Type(ty)) = ab.args.first()
+        {
+            resolved_ty_inner = Some(ty.clone());
         }
 
         Ok(Self {