Remove turbofishes from diesel calls

src/bin/delete-crate.rs

@@ -33,7 +33,7 @@ fn delete(conn: &PgConnection) {
         Some(s) => s,
     };
 
-    let krate = Crate::by_name(&name).first::<Crate>(conn).unwrap();
+    let krate: Crate = Crate::by_name(&name).first(conn).unwrap();
     print!(
         "Are you sure you want to delete {} ({}) [y/N]: ",
         name, krate.id

src/bin/delete-version.rs

@@ -44,10 +44,10 @@ fn delete(conn: &PgConnection) {
         Some(s) => s,
     };
 
-    let krate = Crate::by_name(&name).first::<Crate>(conn).unwrap();
-    let v = Version::belonging_to(&krate)
+    let krate: Crate = Crate::by_name(&name).first(conn).unwrap();
+    let v: Version = Version::belonging_to(&krate)
         .filter(versions::num.eq(&version))
-        .first::<Version>(conn)
+        .first(conn)
         .unwrap();
     print!(
         "Are you sure you want to delete {}#{} ({}) [y/N]: ",

src/bin/monitor.rs

@@ -43,13 +43,14 @@ fn check_failing_background_jobs(conn: &PgConnection) -> Result<()> {
         .map(|s| s.parse::<i32>().unwrap())
         .unwrap_or(15);
 
-    let stalled_job_count = background_jobs
+    let stalled_jobs: Vec<i32> = background_jobs
         .select(1.into_sql::<Integer>())
         .filter(created_at.lt(now - max_job_time.minutes()))
         .for_update()
         .skip_locked()
-        .load::<i32>(conn)?
-        .len();
+        .load(conn)?;
+
+    let stalled_job_count = stalled_jobs.len();
 
     let event = if stalled_job_count > 0 {
         on_call::Event::Trigger {
@@ -84,10 +85,10 @@ fn check_stalled_update_downloads(conn: &PgConnection) -> Result<()> {
         .map(|s| s.parse::<u32>().unwrap() as i64)
         .unwrap_or(120);
 
-    let start_time = background_jobs
+    let start_time: Result<NaiveDateTime, _> = background_jobs
         .filter(job_type.eq("update_downloads"))
         .select(created_at)
-        .first::<NaiveDateTime>(conn);
+        .first(conn);
 
     if let Ok(start_time) = start_time {
         let start_time = DateTime::<Utc>::from_utc(start_time, Utc);
@@ -130,10 +131,10 @@ fn check_spam_attack(conn: &PgConnection) -> Result<()> {
 
     let mut event_description = None;
 
-    let bad_crate = crates::table
+    let bad_crate: Option<String> = crates::table
         .filter(canon_crate_name(crates::name).eq(any(bad_crate_names)))
         .select(crates::name)
-        .first::<String>(conn)
+        .first(conn)
         .optional()?;
 
     if let Some(bad_crate) = bad_crate {
@@ -147,7 +148,7 @@ fn check_spam_attack(conn: &PgConnection) -> Result<()> {
     for author_pattern in bad_author_patterns {
         query = query.or_filter(version_authors::name.like(author_pattern));
     }
-    let bad_author = query.first::<String>(conn).optional()?;
+    let bad_author: Option<String> = query.first(conn).optional()?;
 
     if let Some(bad_author) = bad_author {
         event_description = Some(format!("Crate with author {} published", bad_author));

src/bin/render-readmes.rs

@@ -80,7 +80,7 @@ fn main() {
         query = query.filter(crates::name.eq(crate_name));
     }
 
-    let version_ids = query.load::<i32>(&conn).expect("error loading version ids");
+    let version_ids: Vec<i32> = query.load(&conn).expect("error loading version ids");
 
     let total_versions = version_ids.len();
     println!("Rendering {} versions", total_versions);
@@ -103,11 +103,11 @@ fn main() {
             total_pages
         );
 
-        let versions = versions::table
+        let versions: Vec<(Version, String)> = versions::table
             .inner_join(crates::table)
             .filter(versions::id.eq(any(version_ids_chunk)))
             .select((versions::all_columns, crates::name))
-            .load::<(Version, String)>(&conn)
+            .load(&conn)
             .expect("error loading versions");
 
         let mut tasks = Vec::with_capacity(page_size as usize);

src/bin/transfer-crates.rs

@@ -43,13 +43,13 @@ fn transfer(conn: &PgConnection) {
         Some(s) => s,
     };
 
-    let from = users::table
+    let from: User = users::table
         .filter(users::gh_login.eq(from))
-        .first::<User>(conn)
+        .first(conn)
         .unwrap();
-    let to = users::table
+    let to: User = users::table
         .filter(users::gh_login.eq(to))
-        .first::<User>(conn)
+        .first(conn)
         .unwrap();
 
     if from.gh_id != to.gh_id {
@@ -73,9 +73,9 @@ fn transfer(conn: &PgConnection) {
     let crate_owners = crate_owners::table
         .filter(crate_owners::owner_id.eq(from.id))
         .filter(crate_owners::owner_kind.eq(OwnerKind::User as i32));
-    let crates = Crate::all()
+    let crates: Vec<Crate> = Crate::all()
         .filter(crates::id.eq_any(crate_owners.select(crate_owners::crate_id)))
-        .load::<Crate>(conn)
+        .load(conn)
         .unwrap();
 
     for krate in crates {

src/boot/categories.rs

@@ -103,7 +103,7 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> Result<()> {
         .collect::<Vec<_>>();
 
     conn.transaction(|| {
-        let slugs = diesel::insert_into(categories)
+        let slugs: Vec<String> = diesel::insert_into(categories)
             .values(&to_insert)
             .on_conflict(slug)
             .do_update()
@@ -112,7 +112,7 @@ pub fn sync_with_connection(toml_str: &str, conn: &PgConnection) -> Result<()> {
                 description.eq(excluded(description)),
             ))
             .returning(slug)
-            .get_results::<String>(&*conn)?;
+            .get_results(&*conn)?;
 
         diesel::delete(categories)
             .filter(slug.ne(all(slugs)))

src/controllers/category.rs

@@ -43,7 +43,7 @@ pub fn index(req: &mut dyn RequestExt) -> EndpointResult {
 pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
     let slug = &req.params()["category_id"];
     let conn = req.db_conn()?;
-    let cat = Category::by_slug(slug).first::<Category>(&*conn)?;
+    let cat: Category = Category::by_slug(slug).first(&*conn)?;
     let subcats = cat
         .subcategories(&conn)?
         .into_iter()

src/controllers/crate_owner_invitation.rs

@@ -9,9 +9,10 @@ pub fn list(req: &mut dyn RequestExt) -> EndpointResult {
     let user_id = req.authenticate()?.user_id();
     let conn = &*req.db_conn()?;
 
-    let crate_owner_invitations = crate_owner_invitations::table
+    let crate_owner_invitations: Vec<CrateOwnerInvitation> = crate_owner_invitations::table
         .filter(crate_owner_invitations::invited_user_id.eq(user_id))
-        .load::<CrateOwnerInvitation>(&*conn)?
+        .load(&*conn)?;
+    let crate_owner_invitations = crate_owner_invitations
         .into_iter()
         .map(|i| i.encodable(conn))
         .collect();
@@ -56,7 +57,7 @@ pub fn handle_invite_with_token(req: &mut dyn RequestExt) -> EndpointResult {
 
     let crate_owner_invite: CrateOwnerInvitation = crate_owner_invitations::table
         .filter(crate_owner_invitations::token.eq(req_token))
-        .first::<CrateOwnerInvitation>(&*conn)?;
+        .first(&*conn)?;
 
     let invite_reponse = InvitationResponse {
         crate_id: crate_owner_invite.crate_id,
@@ -79,9 +80,9 @@ fn accept_invite(
     use diesel::{delete, insert_into};
 
     conn.transaction(|| {
-        let pending_crate_owner = crate_owner_invitations::table
+        let pending_crate_owner: CrateOwnerInvitation = crate_owner_invitations::table
             .find((user_id, crate_invite.crate_id))
-            .first::<CrateOwnerInvitation>(&*conn)?;
+            .first(&*conn)?;
 
         insert_into(crate_owners::table)
             .values(&CrateOwner {

src/controllers/keyword.rs

@@ -1,6 +1,6 @@
 use super::prelude::*;
 
-use crate::controllers::helpers::Paginate;
+use crate::controllers::helpers::{pagination::Paginated, Paginate};
 use crate::models::Keyword;
 use crate::views::EncodableKeyword;
 
@@ -20,7 +20,7 @@ pub fn index(req: &mut dyn RequestExt) -> EndpointResult {
         query = query.order(keywords::keyword.asc());
     }
 
-    let data = query.paginate(&req.query())?.load::<Keyword>(&*conn)?;
+    let data: Paginated<Keyword> = query.paginate(&req.query())?.load(&*conn)?;
     let total = data.total();
     let kws = data.into_iter().map(Keyword::encodable).collect::<Vec<_>>();
 

src/controllers/krate/downloads.rs

@@ -20,9 +20,9 @@ pub fn downloads(req: &mut dyn RequestExt) -> EndpointResult {
 
     let crate_name = &req.params()["crate_id"];
     let conn = req.db_read_only()?;
-    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
 
-    let mut versions = krate.all_versions().load::<Version>(&*conn)?;
+    let mut versions: Vec<Version> = krate.all_versions().load(&*conn)?;
     versions.sort_by(|a, b| b.num.cmp(&a.num));
     let (latest_five, rest) = versions.split_at(cmp::min(5, versions.len()));
 
@@ -35,15 +35,15 @@ pub fn downloads(req: &mut dyn RequestExt) -> EndpointResult {
         .collect::<Vec<_>>();
 
     let sum_downloads = sql::<BigInt>("SUM(version_downloads.downloads)");
-    let extra = VersionDownload::belonging_to(rest)
+    let extra: Vec<ExtraDownload> = VersionDownload::belonging_to(rest)
         .select((
             to_char(version_downloads::date, "YYYY-MM-DD"),
             sum_downloads,
         ))
         .filter(version_downloads::date.gt(date(now - 90.days())))
         .group_by(version_downloads::date)
         .order(version_downloads::date.asc())
-        .load::<ExtraDownload>(&*conn)?;
+        .load(&*conn)?;
 
     #[derive(Serialize, Queryable)]
     struct ExtraDownload {

src/controllers/krate/metadata.rs

@@ -32,7 +32,7 @@ pub fn summary(req: &mut dyn RequestExt) -> EndpointResult {
 
         let krates = data.into_iter().map(|(c, _)| c).collect::<Vec<_>>();
 
-        let versions = krates.versions().load::<Version>(&*conn)?;
+        let versions: Vec<Version> = krates.versions().load(&*conn)?;
         versions
             .grouped_by(&krates)
             .into_iter()
@@ -114,13 +114,13 @@ pub fn summary(req: &mut dyn RequestExt) -> EndpointResult {
 pub fn show(req: &mut dyn RequestExt) -> EndpointResult {
     let name = &req.params()["crate_id"];
     let conn = req.db_read_only()?;
-    let krate = Crate::by_name(name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(name).first(&*conn)?;
 
-    let mut versions_and_publishers = krate
+    let mut versions_and_publishers: Vec<(Version, Option<User>)> = krate
         .all_versions()
         .left_outer_join(users::table)
         .select((versions::all_columns, users::all_columns.nullable()))
-        .load::<(Version, Option<User>)>(&*conn)?;
+        .load(&*conn)?;
     versions_and_publishers.sort_by(|a, b| b.0.num.cmp(&a.0.num));
     let versions = versions_and_publishers
         .iter()
@@ -210,7 +210,7 @@ pub fn readme(req: &mut dyn RequestExt) -> EndpointResult {
 pub fn versions(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_name = &req.params()["crate_id"];
     let conn = req.db_read_only()?;
-    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
     let mut versions_and_publishers: Vec<(Version, Option<User>)> = krate
         .all_versions()
         .left_outer_join(users::table)
@@ -241,7 +241,7 @@ pub fn reverse_dependencies(req: &mut dyn RequestExt) -> EndpointResult {
 
     let name = &req.params()["crate_id"];
     let conn = req.db_read_only()?;
-    let krate = Crate::by_name(name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(name).first(&*conn)?;
     let (rev_deps, total) = krate.reverse_dependencies(&*conn, &req.query())?;
     let rev_deps: Vec<_> = rev_deps
         .into_iter()
@@ -250,7 +250,7 @@ pub fn reverse_dependencies(req: &mut dyn RequestExt) -> EndpointResult {
 
     let version_ids: Vec<i32> = rev_deps.iter().map(|dep| dep.version_id).collect();
 
-    let versions_and_publishers = versions::table
+    let versions_and_publishers: Vec<(Version, String, Option<User>)> = versions::table
         .filter(versions::id.eq(any(version_ids)))
         .inner_join(crates::table)
         .left_outer_join(users::table)
@@ -259,7 +259,7 @@ pub fn reverse_dependencies(req: &mut dyn RequestExt) -> EndpointResult {
             crates::name,
             users::all_columns.nullable(),
         ))
-        .load::<(Version, String, Option<User>)>(&*conn)?;
+        .load(&*conn)?;
     let versions = versions_and_publishers
         .iter()
         .map(|(v, _, _)| v)

src/controllers/krate/owners.rs

@@ -8,7 +8,7 @@ use crate::views::EncodableOwner;
 pub fn owners(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_name = &req.params()["crate_id"];
     let conn = req.db_conn()?;
-    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
     let owners = krate
         .owners(&conn)?
         .into_iter()
@@ -26,7 +26,7 @@ pub fn owners(req: &mut dyn RequestExt) -> EndpointResult {
 pub fn owner_team(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_name = &req.params()["crate_id"];
     let conn = req.db_conn()?;
-    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
     let owners = Team::owning(&krate, &conn)?
         .into_iter()
         .map(Owner::encodable)
@@ -43,7 +43,7 @@ pub fn owner_team(req: &mut dyn RequestExt) -> EndpointResult {
 pub fn owner_user(req: &mut dyn RequestExt) -> EndpointResult {
     let crate_name = &req.params()["crate_id"];
     let conn = req.db_conn()?;
-    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+    let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
     let owners = User::owning(&krate, &conn)?
         .into_iter()
         .map(Owner::encodable)
@@ -97,7 +97,7 @@ fn modify_owners(req: &mut dyn RequestExt, add: bool) -> EndpointResult {
     let user = authenticated_user.user();
 
     conn.transaction(|| {
-        let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+        let krate: Crate = Crate::by_name(crate_name).first(&*conn)?;
         let owners = krate.owners(&conn)?;
 
         match user.rights(app, &owners)? {

src/controllers/krate/search.rs

@@ -11,6 +11,7 @@ use crate::schema::*;
 use crate::util::errors::{bad_request, ChainError};
 use crate::views::EncodableCrate;
 
+use crate::controllers::helpers::pagination::Paginated;
 use crate::models::krate::{canon_crate_name, ALL_COLUMNS};
 
 /// Handles the `GET /crates` route.
@@ -188,9 +189,7 @@ pub fn search(req: &mut dyn RequestExt) -> EndpointResult {
         query = query.then_order_by(crates::name.asc())
     }
 
-    let data = query
-        .paginate(&req.query())?
-        .load::<(Crate, bool, Option<i64>)>(&*conn)?;
+    let data: Paginated<(Crate, bool, Option<i64>)> = query.paginate(&req.query())?.load(&*conn)?;
     let total = data.total();
 
     let next_page = data.next_page_params().map(|p| req.query_with_params(p));
@@ -203,16 +202,16 @@ pub fn search(req: &mut dyn RequestExt) -> EndpointResult {
         .collect::<Vec<_>>();
     let crates = data.into_iter().map(|(c, _, _)| c).collect::<Vec<_>>();
 
-    let versions = crates
-        .versions()
-        .load::<Version>(&*conn)?
+    let versions: Vec<Version> = crates.versions().load(&*conn)?;
+    let versions = versions
         .grouped_by(&crates)
         .into_iter()
         .map(|versions| Version::top(versions.into_iter().map(|v| (v.created_at, v.num))));
 
-    let badges = CrateBadge::belonging_to(&crates)
+    let badges: Vec<CrateBadge> = CrateBadge::belonging_to(&crates)
         .select((badges::crate_id, badges::all_columns))
-        .load::<CrateBadge>(&*conn)?
+        .load(&*conn)?;
+    let badges = badges
         .grouped_by(&crates)
         .into_iter()
         .map(|badges| badges.into_iter().map(|cb| cb.badge).collect());

src/controllers/team.rs

@@ -10,7 +10,7 @@ pub fn show_team(req: &mut dyn RequestExt) -> EndpointResult {
 
     let name = &req.params()["team_id"];
     let conn = req.db_conn()?;
-    let team = teams.filter(login.eq(name)).first::<Team>(&*conn)?;
+    let team: Team = teams.filter(login.eq(name)).first(&*conn)?;
 
     #[derive(Serialize)]
     struct R {

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: {}",