Import type names instead of writing their paths (#355)

The style guide imports types and uses them unqualified. 222 places
wrote a path such as std::collections::HashMap or std::time::Duration
inline; each file now imports the type once, one use a module, and
names it bare. Done with a script, file by file, only where the name is
unambiguous there:
- one path for the name throughout the file, and not a name the file
  already binds otherwise (its own types, other imports, a function's
  local use);
- not a name generic enough to mislead bare (Error, Result, Value,
  Mutex, Client, Request, Response, Command, Event, Context, Map, Ok);
- only code a normal build compiles, so no import is unused outside
  tests or names a crate only tests depend on.

193 paths stay, those cases above. No behaviour change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/directory/src/lib.rs

@@ -26,7 +26,13 @@ use axum::{Extension, Json, Router};
 use serde::{Deserialize, Serialize};
 
 use config::{Access, Token};
+use reqwest::redirect::Policy;
+use std::path::PathBuf;
 use store::{Refreshed, Store};
+use tokio::sync::Notify;
+use tower_http::compression::CompressionLayer;
+use tower_http::decompression::RequestDecompressionLayer;
+use tracing::Instrument;
 
 /// A feed as the directory lists it.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -134,7 +140,7 @@ pub struct Directory {
     tokens: RwLock<Vec<Token>>,
     client: reqwest::Client,
     /// Wakes the refresher, so a feed a snapshot brings in is fetched now, not in a minute.
-    wake: tokio::sync::Notify,
+    wake: Notify,
     /// The public pages' copy of the list, and when it was read.
     pages_list: tokio::sync::Mutex<Option<(Instant, Arc<Vec<Listing>>)>>,
 }
@@ -155,9 +161,9 @@ impl Directory {
     ) -> Result<Shared, reqwest::Error> {
         // No redirects: ipx_feed::fetch follows them itself, so it sees each hop.
         let client = reqwest::Client::builder()
-            .connect_timeout(std::time::Duration::from_secs(10))
+            .connect_timeout(Duration::from_secs(10))
             .read_timeout(ipx_feed::FEED_SILENCE)
-            .redirect(reqwest::redirect::Policy::none())
+            .redirect(Policy::none())
             .user_agent(concat!("ipx-directory/", env!("CARGO_PKG_VERSION")))
             // The feeds are named by whoever holds a write token, and redirect where their
             // publishers like: nothing on this network is fetched unless listed (#329).
@@ -167,7 +173,7 @@ impl Directory {
             store,
             tokens: RwLock::new(tokens),
             client,
-            wake: tokio::sync::Notify::new(),
+            wake: Notify::new(),
             pages_list: Default::default(),
         }))
     }
@@ -239,14 +245,14 @@ pub async fn refresher(dir: Shared) {
                 if !due.is_empty() {
                     // A round is a trace, each feed's check a span in it (#213).
                     let round = tracing::info_span!("refresh", feeds = due.len());
-                    tracing::Instrument::instrument(
+                    Instrument::instrument(
                         async {
                             // A few at a time: in turn, two publishers timing out held a round
                             // for a minute and more (#227).
                             futures_util::StreamExt::for_each_concurrent(futures_util::stream::iter(&due), 5, |d| {
                                 let check = tracing::info_span!("feed", feed = %d.id);
                                 async {
-                                    if let Err(e) = tracing::Instrument::instrument(dir.refresh(d), check).await {
+                                    if let Err(e) = Instrument::instrument(dir.refresh(d), check).await {
                                         tracing::warn!(feed = %d.id, error = %format!("{e:#}"), "could not store a feed check");
                                     }
                                 }
@@ -272,7 +278,7 @@ pub async fn refresher(dir: Shared) {
 
 /// Reads the config file again whenever it changes, checked each minute. A file that fails to
 /// load leaves the tokens as they were, so a typo locks nobody out.
-pub async fn reloader(dir: Shared, path: std::path::PathBuf) {
+pub async fn reloader(dir: Shared, path: PathBuf) {
     let mtime = |p: &std::path::Path| std::fs::metadata(p).and_then(|m| m.modified()).ok();
     let mut last = mtime(&path);
     loop {
@@ -321,9 +327,9 @@ pub fn router(dir: Shared) -> Router {
         // Brotli, zstd or gzip as the caller takes them: the feed list went to ipx as 603 KB of
         // JSON, most of a Directory page's time (#253). Inside the access log, which records what
         // was sent.
-        .layer(tower_http::compression::CompressionLayer::new().br(true).zstd(true).gzip(true))
+        .layer(CompressionLayer::new().br(true).zstd(true).gzip(true))
         // And takes a request's body gzipped: ipx sends its snapshot so, about 100 KB as JSON.
-        .layer(tower_http::decompression::RequestDecompressionLayer::new().gzip(true))
+        .layer(RequestDecompressionLayer::new().gzip(true))
         .layer(axum::middleware::from_fn(access_log))
         .with_state(dir)
 }
@@ -368,7 +374,7 @@ async fn access_log(req: Request, next: Next) -> Response {
         use tracing_opentelemetry::OpenTelemetrySpanExt;
         let _ = span.set_parent(parent);
     }
-    let resp = tracing::Instrument::instrument(next.run(req), span.clone()).await;
+    let resp = Instrument::instrument(next.run(req), span.clone()).await;
     span.record("http.response.status_code", resp.status().as_u16());
     let _in = span.enter();
     let who = resp.extensions().get::<Who>().map_or("", |w| w.0.as_str()).to_owned();