fix: resolve redundant closures and more auto-deref warnings

- Remove redundant closures in lquery and ltree types
- Fix auto-deref issues in postgres options parser
- Fix auto-deref issues in postgres type_info

Author: cursoragent

sqlx-core/src/postgres/options/parse.rs

@@ -48,18 +48,18 @@ impl FromStr for PgConnectOptions {
         }
 
         for (key, value) in url.query_pairs().into_iter() {
-            match &*key {
+            match &key as &str {
                 "sslmode" | "ssl-mode" => {
                     options = options.ssl_mode(value.parse().map_err(Error::config)?);
                 }
 
                 "sslrootcert" | "ssl-root-cert" | "ssl-ca" => {
-                    options = options.ssl_root_cert(&*value);
+                    options = options.ssl_root_cert(&value);
                 }
 
-                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&*value),
+                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&value),
 
-                "sslkey" | "ssl-key" => options = options.ssl_client_key(&*value),
+                "sslkey" | "ssl-key" => options = options.ssl_client_key(&value),
 
                 "statement-cache-capacity" => {
                     options =
@@ -68,39 +68,39 @@ impl FromStr for PgConnectOptions {
 
                 "host" => {
                     if value.starts_with("/") {
-                        options = options.socket(&*value);
+                        options = options.socket(&value);
                     } else {
-                        options = options.host(&*value);
+                        options = options.host(&value);
                     }
                 }
 
                 "hostaddr" => {
                     value.parse::<IpAddr>().map_err(Error::config)?;
-                    options = options.host(&*value)
+                    options = options.host(&value)
                 }
 
                 "port" => options = options.port(value.parse().map_err(Error::config)?),
 
-                "dbname" => options = options.database(&*value),
+                "dbname" => options = options.database(&value),
 
-                "user" => options = options.username(&*value),
+                "user" => options = options.username(&value),
 
-                "password" => options = options.password(&*value),
+                "password" => options = options.password(&value),
 
-                "application_name" => options = options.application_name(&*value),
+                "application_name" => options = options.application_name(&value),
 
                 "options" => {
                     if let Some(options) = options.options.as_mut() {
                         options.push(' ');
-                        options.push_str(&*value);
+                        options.push_str(&value);
                     } else {
                         options.options = Some(value.to_string());
                     }
                 }
 
                 k if k.starts_with("options[") => {
                     if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
-                        options = options.options([(key, &*value)]);
+                        options = options.options([(key, &value)]);
                     }
                 }
 

sqlx-core/src/postgres/type_info.rs

@@ -540,7 +540,7 @@ impl PgType {
             PgType::Money => "MONEY",
             PgType::MoneyArray => "MONEY[]",
             PgType::Void => "VOID",
-            PgType::Custom(ty) => &*ty.name,
+            PgType::Custom(ty) => &ty.name,
             PgType::DeclareWithOid(_) => "?",
             PgType::DeclareWithName(name) => name,
         }
@@ -640,7 +640,7 @@ impl PgType {
             PgType::Money => "money",
             PgType::MoneyArray => "_money",
             PgType::Void => "void",
-            PgType::Custom(ty) => &*ty.name,
+            PgType::Custom(ty) => &ty.name,
             PgType::DeclareWithOid(_) => "?",
             PgType::DeclareWithName(name) => name,
         }

sqlx-core/src/postgres/types/lquery.rs

@@ -104,7 +104,7 @@ impl FromStr for PgLQuery {
         Ok(Self {
             levels: s
                 .split('.')
-                .map(|s| PgLQueryLevel::from_str(s))
+                .map(PgLQueryLevel::from_str)
                 .collect::<Result<_, Self::Err>>()?,
         })
     }
@@ -245,12 +245,12 @@ impl FromStr for PgLQueryLevel {
                 b'!' => Ok(PgLQueryLevel::NotNonStar(
                     s[1..]
                         .split('|')
-                        .map(|s| PgLQueryVariant::from_str(s))
+                        .map(PgLQueryVariant::from_str)
                         .collect::<Result<Vec<_>, PgLQueryParseError>>()?,
                 )),
                 _ => Ok(PgLQueryLevel::NonStar(
                     s.split('|')
-                        .map(|s| PgLQueryVariant::from_str(s))
+                        .map(PgLQueryVariant::from_str)
                         .collect::<Result<Vec<_>, PgLQueryParseError>>()?,
                 )),
             }

sqlx-core/src/postgres/types/ltree.rs

@@ -142,7 +142,7 @@ impl FromStr for PgLTree {
         Ok(Self {
             labels: s
                 .split('.')
-                .map(|s| PgLTreeLabel::new(s))
+                .map(PgLTreeLabel::new)
                 .collect::<Result<Vec<_>, Self::Err>>()?,
         })
     }