Remove turbofishes from .get_result() calls

This makes the code a little more readable and helps `intellij-rust` in understanding the types of the variables

Author: Turbo87

src/controllers/token.rs

@@ -72,9 +72,7 @@ pub fn new(req: &mut dyn RequestExt) -> EndpointResult {
     let user = authenticated_user.user();
 
     let max_token_per_user = 500;
-    let count = ApiToken::belonging_to(&user)
-        .count()
-        .get_result::<i64>(&*conn)?;
+    let count: i64 = ApiToken::belonging_to(&user).count().get_result(&*conn)?;
     if count >= max_token_per_user {
         return Err(bad_request(&format!(
             "maximum tokens per user is: {}",

src/controllers/user/me.rs

@@ -149,13 +149,13 @@ pub fn update_user(req: &mut dyn RequestExt) -> EndpointResult {
             email: user_email,
         };
 
-        let token = insert_into(emails::table)
+        let token: String = insert_into(emails::table)
             .values(&new_email)
             .on_conflict(user_id)
             .do_update()
             .set(&new_email)
             .returning(emails::token)
-            .get_result::<String>(&*conn)
+            .get_result(&*conn)
             .map_err(|_| server_error("Error in creating token"))?;
 
         crate::email::send_user_confirm_email(user_email, &user.gh_login, &token);
@@ -202,9 +202,9 @@ pub fn regenerate_token_and_send(req: &mut dyn RequestExt) -> EndpointResult {
     }
 
     conn.transaction(|| {
-        let email = update(Email::belonging_to(&user))
+        let email: Email = update(Email::belonging_to(&user))
             .set(emails::token.eq(sql("DEFAULT")))
-            .get_result::<Email>(&*conn)
+            .get_result(&*conn)
             .map_err(|_| bad_request("Email could not be found"))?;
 
         email::try_send_user_confirm_email(&email.email, &user.gh_login, &email.token)

src/models/krate.rs

@@ -163,10 +163,10 @@ impl<'a> NewCrate<'a> {
         use diesel::dsl::exists;
         use diesel::select;
 
-        let reserved_name = select(exists(
+        let reserved_name: bool = select(exists(
             reserved_crate_names.filter(canon_crate_name(name).eq(canon_crate_name(self.name))),
         ))
-        .get_result::<bool>(conn)?;
+        .get_result(conn)?;
         if reserved_name {
             Err(cargo_err("cannot upload a crate with a reserved name"))
         } else {
@@ -178,11 +178,11 @@ impl<'a> NewCrate<'a> {
         use crate::schema::crates::dsl::*;
 
         conn.transaction(|| {
-            let maybe_inserted = diesel::insert_into(crates)
+            let maybe_inserted: Option<Crate> = diesel::insert_into(crates)
                 .values(self)
                 .on_conflict_do_nothing()
                 .returning(ALL_COLUMNS)
-                .get_result::<Crate>(conn)
+                .get_result(conn)
                 .optional()?;
 
             if let Some(ref krate) = maybe_inserted {
@@ -445,15 +445,16 @@ impl Crate {
         match owner {
             // Users are invited and must accept before being added
             Owner::User(user) => {
-                let maybe_inserted = insert_into(crate_owner_invitations::table)
-                    .values(&NewCrateOwnerInvitation {
-                        invited_user_id: user.id,
-                        invited_by_user_id: req_user.id,
-                        crate_id: self.id,
-                    })
-                    .on_conflict_do_nothing()
-                    .get_result::<CrateOwnerInvitation>(conn)
-                    .optional()?;
+                let maybe_inserted: Option<CrateOwnerInvitation> =
+                    insert_into(crate_owner_invitations::table)
+                        .values(&NewCrateOwnerInvitation {
+                            invited_user_id: user.id,
+                            invited_by_user_id: req_user.id,
+                            crate_id: self.id,
+                        })
+                        .on_conflict_do_nothing()
+                        .get_result(conn)
+                        .optional()?;
 
                 if let Some(ownership_invitation) = maybe_inserted {
                     if let Ok(Some(email)) = user.verified_email(&conn) {

src/models/token.rs

@@ -43,13 +43,13 @@ impl ApiToken {
             crate::util::generate_secure_alphanumeric_string(TOKEN_LENGTH)
         );
 
-        let model = diesel::insert_into(api_tokens::table)
+        let model: ApiToken = diesel::insert_into(api_tokens::table)
             .values((
                 api_tokens::user_id.eq(user_id),
                 api_tokens::name.eq(name),
                 api_tokens::token.eq(digest(&plaintext, "sha256")),
             ))
-            .get_result::<ApiToken>(conn)?;
+            .get_result(conn)?;
 
         Ok(CreatedApiToken { plaintext, model })
     }
@@ -71,7 +71,7 @@ impl ApiToken {
         conn.transaction(|| {
             update(tokens)
                 .set(last_used_at.eq(now.nullable()))
-                .get_result::<ApiToken>(conn)
+                .get_result(conn)
         })
         .or_else(|_| tokens.first(conn))
         .map_err(Into::into)

src/models/user.rs

@@ -63,7 +63,7 @@ impl<'a> NewUser<'a> {
         use diesel::sql_types::Integer;
 
         conn.transaction(|| {
-            let user = insert_into(users)
+            let user: User = insert_into(users)
                 .values(self)
                 // We need the `WHERE gh_id > 0` condition here because `gh_id` set
                 // to `-1` indicates that we were unable to find a GitHub ID for
@@ -81,7 +81,7 @@ impl<'a> NewUser<'a> {
                     gh_avatar.eq(excluded(gh_avatar)),
                     gh_access_token.eq(excluded(gh_access_token)),
                 ))
-                .get_result::<User>(conn)?;
+                .get_result(conn)?;
 
             // To send the user an account verification email
             if let Some(user_email) = email {
@@ -90,11 +90,11 @@ impl<'a> NewUser<'a> {
                     email: user_email,
                 };
 
-                let token = insert_into(emails::table)
+                let token: Option<String> = insert_into(emails::table)
                     .values(&new_email)
                     .on_conflict_do_nothing()
                     .returning(emails::token)
-                    .get_result::<String>(conn)
+                    .get_result(conn)
                     .optional()?;
 
                 if let Some(token) = token {

src/models/version.rs

@@ -210,9 +210,7 @@ impl NewVersion {
                 )));
             }
 
-            let version = insert_into(versions)
-                .values(self)
-                .get_result::<Version>(conn)?;
+            let version: Version = insert_into(versions).values(self).get_result(conn)?;
 
             insert_into(versions_published_by::table)
                 .values((

src/tasks/update_downloads.rs

@@ -51,10 +51,10 @@ fn collect(conn: &PgConnection, rows: &[VersionDownload]) -> QueryResult<()> {
 
         conn.transaction::<_, diesel::result::Error, _>(|| {
             // Update the total number of version downloads
-            let crate_id = update(versions::table.find(download.version_id))
+            let crate_id: i32 = update(versions::table.find(download.version_id))
                 .set(versions::downloads.eq(versions::downloads + amt))
                 .returning(versions::crate_id)
-                .get_result::<i32>(conn)?;
+                .get_result(conn)?;
 
             // Update the total number of crate downloads
             update(crates::table.find(crate_id))

src/tests/read_only_mode.rs

@@ -52,9 +52,8 @@ fn can_download_crate_in_read_only_mode() {
         use cargo_registry::schema::version_downloads::dsl::*;
         use diesel::dsl::sum;
 
-        let dl_count = version_downloads
-            .select(sum(downloads))
-            .get_result::<Option<i64>>(conn);
+        let dl_count: Result<Option<i64>, _> =
+            version_downloads.select(sum(downloads)).get_result(conn);
         assert_eq!(Ok(None), dl_count);
     })
 }