enable unused_qualifications lint

src/api/ruma_wrapper/axum.rs

@@ -326,7 +326,7 @@ where
             };
 
         let mut http_request =
-            http::Request::builder().uri(parts.uri).method(parts.method);
+            Request::builder().uri(parts.uri).method(parts.method);
         *http_request.headers_mut().unwrap() = parts.headers;
 
         if let Some(CanonicalJsonValue::Object(json_body)) = &mut json_body {

src/database.rs

@@ -305,7 +305,7 @@ impl KeyValueDatabase {
         Self::check_db_setup(&config)?;
 
         if !Path::new(&config.database_path).exists() {
-            std::fs::create_dir_all(&config.database_path).map_err(|_| {
+            fs::create_dir_all(&config.database_path).map_err(|_| {
                 Error::BadConfig(
                     "Database folder doesn't exists and couldn't be created \
                      (e.g. due to missing permissions). Please create the \
@@ -1085,8 +1085,7 @@ impl KeyValueDatabase {
                         )
                         .unwrap();
 
-                    let user_default_rules =
-                        ruma::push::Ruleset::server_default(&user);
+                    let user_default_rules = Ruleset::server_default(&user);
                     account_data
                         .content
                         .global

src/database/abstraction/watchers.rs

@@ -23,7 +23,7 @@ impl Watchers {
         {
             hash_map::Entry::Occupied(o) => o.get().1.clone(),
             hash_map::Entry::Vacant(v) => {
-                let (tx, rx) = tokio::sync::watch::channel(());
+                let (tx, rx) = watch::channel(());
                 v.insert((tx, rx.clone()));
                 rx
             }

src/main.rs

@@ -272,7 +272,7 @@ async fn run_server() -> io::Result<()> {
 /// The axum request handler task gets cancelled if the connection is shut down;
 /// by spawning our own task, processing continue after the client disconnects.
 async fn spawn_task<B: Send + 'static>(
-    req: axum::http::Request<B>,
+    req: http::Request<B>,
     next: axum::middleware::Next<B>,
 ) -> std::result::Result<axum::response::Response, StatusCode> {
     if services().globals.shutdown.load(atomic::Ordering::Relaxed) {
@@ -284,13 +284,13 @@ async fn spawn_task<B: Send + 'static>(
 }
 
 async fn unrecognized_method<B: Send>(
-    req: axum::http::Request<B>,
+    req: http::Request<B>,
     next: axum::middleware::Next<B>,
 ) -> std::result::Result<axum::response::Response, StatusCode> {
     let method = req.method().clone();
     let uri = req.uri().clone();
     let inner = next.run(req).await;
-    if inner.status() == axum::http::StatusCode::METHOD_NOT_ALLOWED {
+    if inner.status() == StatusCode::METHOD_NOT_ALLOWED {
         warn!("Method not allowed: {method} {uri}");
         return Ok(Ra(UiaaResponse::MatrixError(RumaError {
             body: ErrorBody::Standard {

src/service/rooms/spaces.rs

@@ -545,7 +545,7 @@ impl Service {
         match join_rule {
             JoinRule::Restricted(r) => {
                 for rule in &r.allow {
-                    if let join_rules::AllowRule::RoomMembership(rm) = rule {
+                    if let AllowRule::RoomMembership(rm) = rule {
                         if let Ok(true) = services()
                             .rooms
                             .state_cache

src/utils.rs

@@ -145,20 +145,17 @@ pub(crate) fn deserialize_from_str<
     'de,
     D: serde::de::Deserializer<'de>,
     T: FromStr<Err = E>,
-    E: std::fmt::Display,
+    E: fmt::Display,
 >(
     deserializer: D,
 ) -> Result<T, D::Error> {
     struct Visitor<T: FromStr<Err = E>, E>(std::marker::PhantomData<T>);
-    impl<T: FromStr<Err = Err>, Err: std::fmt::Display> serde::de::Visitor<'_>
+    impl<T: FromStr<Err = Err>, Err: fmt::Display> serde::de::Visitor<'_>
         for Visitor<T, Err>
     {
         type Value = T;
 
-        fn expecting(
-            &self,
-            formatter: &mut std::fmt::Formatter<'_>,
-        ) -> std::fmt::Result {
+        fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
             write!(formatter, "a parsable string")
         }