chore: bump rust edition and fix lints

Author: eladyn

Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 authors = ["Simon Persson <[email protected]>", "Sven Lechner <[email protected]>", "eladyn <[email protected]>"]
-edition = "2018"
+edition = "2024"
 name = "spotifyd"
 description = "A Spotify daemon"
 repository = "https://github.com/Spotifyd/spotifyd"
 license = "GPL-3.0-only"
 version = "0.4.1"
 resolver = "2"
-rust-version = "1.82"
+rust-version = "1.85"
 
 [dependencies]
 alsa = { version = "0.9.1", optional = true }

src/config.rs

@@ -1,24 +1,24 @@
 use crate::utils;
 use clap::{
-    builder::{IntoResettable, PossibleValuesParser, TypedValueParser, ValueParser},
     Args, Parser, Subcommand, ValueEnum,
+    builder::{IntoResettable, PossibleValuesParser, TypedValueParser, ValueParser},
 };
 use color_eyre::{
-    eyre::{bail, Context},
     Report,
+    eyre::{Context, bail},
 };
 use directories::ProjectDirs;
 use gethostname::gethostname;
 use librespot_core::{cache::Cache, config::DeviceType as LSDeviceType, config::SessionConfig};
 use librespot_playback::{
     audio_backend,
     config::{AudioFormat as LSAudioFormat, Bitrate as LSBitrate, PlayerConfig},
-    dither::{mk_ditherer, DithererBuilder, TriangularDitherer},
+    dither::{DithererBuilder, TriangularDitherer, mk_ditherer},
 };
 use log::{debug, error, info, warn};
 use serde::{
-    de::{self, Error, Unexpected},
     Deserialize, Deserializer,
+    de::{self, Error, Unexpected},
 };
 use sha1::{Digest, Sha1};
 use std::{
@@ -488,10 +488,14 @@ impl CliConfig {
             if let Some(problem) = get_known_config_problem(&path) {
                 match problem {
                     KnownConfigProblem::MissingFeature(feature) => {
-                        warn!("The config key '{path}' is ignored, because the feature '{feature}' is missing in this build");
+                        warn!(
+                            "The config key '{path}' is ignored, because the feature '{feature}' is missing in this build"
+                        );
                     }
                     KnownConfigProblem::UsernamePassword => {
-                        warn!("The config key '{path}' is ignored, because authentication with username and password is no longer supported by Spotify. Please use `spotifyd authenticate` instead");
+                        warn!(
+                            "The config key '{path}' is ignored, because authentication with username and password is no longer supported by Spotify. Please use `spotifyd authenticate` instead"
+                        );
                     }
                 }
             } else {

src/dbus_mpris.rs

@@ -1,20 +1,20 @@
 use crate::config::DBusType;
-use chrono::{prelude::*, Duration};
+use chrono::{Duration, prelude::*};
 use dbus::{
+    MethodErr,
     arg::{RefArg, Variant},
     channel::{MatchingReceiver, Sender},
     message::{MatchRule, SignalArgs},
     nonblock::stdintf::org_freedesktop_dbus::PropertiesPropertiesChanged,
-    MethodErr,
 };
 use dbus_crossroads::{Crossroads, IfaceToken};
 use dbus_tokio::connection::{self, IOResourceError};
 use futures::{
-    task::{Context, Poll},
     Future,
+    task::{Context, Poll},
 };
 use librespot_connect::spirc::{Spirc, SpircLoadCommand};
-use librespot_core::{spotify_id::SpotifyItemType, Session, SpotifyId};
+use librespot_core::{Session, SpotifyId, spotify_id::SpotifyItemType};
 use librespot_metadata::audio::AudioItem;
 use librespot_playback::player::PlayerEvent;
 use librespot_protocol::spirc::TrackRef;
@@ -30,8 +30,8 @@ use time::format_description::well_known::Iso8601;
 use tokio::{
     runtime::Handle,
     sync::{
-        mpsc::{UnboundedReceiver, UnboundedSender},
         Mutex,
+        mpsc::{UnboundedReceiver, UnboundedSender},
     },
 };
 
@@ -386,11 +386,13 @@ impl CurrentState {
         Self(RwLock::new(inner))
     }
 
-    fn read(&self) -> Result<std::sync::RwLockReadGuard<CurrentStateInner>, StatePoisonError> {
+    fn read(&self) -> Result<std::sync::RwLockReadGuard<'_, CurrentStateInner>, StatePoisonError> {
         self.0.read().map_err(|_| StatePoisonError)
     }
 
-    fn write(&self) -> Result<std::sync::RwLockWriteGuard<CurrentStateInner>, StatePoisonError> {
+    fn write(
+        &self,
+    ) -> Result<std::sync::RwLockWriteGuard<'_, CurrentStateInner>, StatePoisonError> {
         self.0.write().map_err(|_| StatePoisonError)
     }
 }
@@ -835,7 +837,7 @@ fn register_player_interface(
                     mode => {
                         return Err(dbus::MethodErr::failed(&format!(
                             "unsupported repeat mode: {mode}"
-                        )))
+                        )));
                     }
                 };
                 local_spirc

src/error.rs

@@ -1,22 +1,4 @@
-use std::{
-    error::Error as StdError,
-    fmt::{self, Display},
-};
-
-#[derive(Clone, Debug)]
-pub struct ParseError(String);
-
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "failed to parse config entry: {}", self.0)
-    }
-}
-
-impl StdError for ParseError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        None
-    }
-}
+use std::fmt::{self, Display};
 
 /// This crate's error type.
 #[derive(Debug)]
@@ -90,12 +72,12 @@ impl Display for ErrorKind {
         match self {
             ErrorKind::Subprocess { cmd, msg, shell } => match msg {
                 Message::None => write!(f, "Failed to execute {:?} using {:?}.", cmd, shell),
-                Message::Error(ref e) => write!(
+                Message::Error(e) => write!(
                     f,
                     "Failed to execute {:?} using {:?}. Error: {}",
                     cmd, shell, e
                 ),
-                Message::String(ref s) => write!(
+                Message::String(s) => write!(
                     f,
                     "Failed to execute {:?} using {:?}. Error: {}",
                     cmd, shell, s

src/main.rs

@@ -7,7 +7,7 @@ use config::ExecutionMode;
 #[cfg(unix)]
 use daemonize::Daemonize;
 use fern::colors::ColoredLevelConfig;
-use log::{info, trace, LevelFilter};
+use log::{LevelFilter, info, trace};
 use oauth::run_oauth;
 #[cfg(target_os = "openbsd")]
 use pledge::pledge;
@@ -176,7 +176,7 @@ fn run_daemon(mut cli_config: CliConfig) -> eyre::Result<()> {
         #[cfg(target_os = "windows")]
         {
             use std::os::windows::process::CommandExt;
-            use std::process::{exit, Command};
+            use std::process::{Command, exit};
 
             let mut args = std::env::args().collect::<Vec<_>>();
             args.remove(0);

src/main_loop.rs

@@ -9,15 +9,14 @@ use futures::future::Either;
 #[cfg(not(feature = "dbus_mpris"))]
 use futures::future::Pending;
 use futures::{
-    self,
+    self, Future, FutureExt, StreamExt,
     future::{self, Fuse, FusedFuture},
     stream::Peekable,
-    Future, FutureExt, StreamExt,
 };
 use librespot_connect::{config::ConnectConfig, spirc::Spirc};
 use librespot_core::{
-    authentication::Credentials, cache::Cache, config::DeviceType, session::Session, Error,
-    SessionConfig,
+    Error, SessionConfig, authentication::Credentials, cache::Cache, config::DeviceType,
+    session::Session,
 };
 use librespot_discovery::Discovery;
 use librespot_playback::{
@@ -101,7 +100,9 @@ struct ConnectionInfo<SpircTask: Future<Output = ()>> {
 }
 
 impl MainLoop {
-    async fn get_connection(&mut self) -> Result<ConnectionInfo<impl Future<Output = ()>>, Error> {
+    async fn get_connection(
+        &mut self,
+    ) -> Result<ConnectionInfo<impl Future<Output = ()> + use<>>, Error> {
         let creds = self.credentials_provider.get_credentials().await;
 
         let mut connection_backoff = Backoff::default();
@@ -141,7 +142,7 @@ impl MainLoop {
                         session,
                         player,
                         spirc_task,
-                    })
+                    });
                 }
                 Err(err) => {
                     let Ok(backoff) = connection_backoff.next_backoff() else {

src/oauth.rs

@@ -1,13 +1,13 @@
 use color_eyre::{
-    eyre::{self, Context as _},
     Section as _,
+    eyre::{self, Context as _},
 };
 use librespot_core::SessionConfig;
-use librespot_core::{authentication::Credentials, Session};
+use librespot_core::{Session, authentication::Credentials};
 use log::info;
 use tokio::runtime::Runtime;
 
-use crate::{config::CliConfig, setup_logger, LogTarget};
+use crate::{LogTarget, config::CliConfig, setup_logger};
 
 pub(crate) fn run_oauth(mut cli_config: CliConfig, oauth_port: u16) -> eyre::Result<()> {
     setup_logger(LogTarget::Terminal, cli_config.verbose)?;

src/setup.rs

@@ -5,7 +5,7 @@ use crate::{
     main_loop::{self, CredentialsProvider},
     utils::Backoff,
 };
-use color_eyre::{eyre::eyre, Section};
+use color_eyre::{Section, eyre::eyre};
 use futures::StreamExt as _;
 use librespot_playback::{
     audio_backend::{self},
@@ -116,9 +116,9 @@ pub(crate) fn initial_state(
         (None, Some(creds)) => CredentialsProvider::CredentialsOnly(creds),
         (None, None) => {
             return Err(
-                eyre!("Discovery unavailable and no credentials found.").with_suggestion(|| {
-                    "Try enabling discovery or logging in first with `spotifyd authenticate`."
-                }),
+                eyre!("Discovery unavailable and no credentials found.").with_suggestion(
+                    || "Try enabling discovery or logging in first with `spotifyd authenticate`.",
+                ),
             );
         }
     };

src/utils.rs

@@ -139,7 +139,10 @@ mod tests {
     fn test_envvar_discovery() {
         init_logger();
 
-        env::set_var("SHELL", "fantasy_shell");
+        // SAFETY: this is part of the single-threaded tests
+        unsafe {
+            env::set_var("SHELL", "fantasy_shell");
+        }
 
         let shell = get_shell().unwrap();
         assert_eq!(shell, "fantasy_shell");