Bump MSRV to Rust 1.88 (#3376)

Rust 1.88 stabilizes let chains and clippy will lint places they can be
used.

Author: mkrasnitski

.github/workflows/ci.yml

@@ -3,8 +3,8 @@ name: CI
 on: [push, pull_request]
 
 env:
-  rust_min: 1.85.0
-  rust_nightly: nightly-2025-02-19
+  rust_min: 1.88.0
+  rust_nightly: nightly-2025-06-25
 
 jobs:
   test:

Cargo.toml

@@ -24,7 +24,7 @@ repository = "https://github.com/serenity-rs/serenity.git"
 keywords = ["discord", "api"]
 license = "ISC"
 edition = "2024"
-rust-version = "1.85"
+rust-version = "1.88"
 
 [dependencies]
 # Required dependencies

README.md

@@ -101,7 +101,7 @@ tokio = { version = "1.21.2", features = ["macros", "rt-multi-thread"] }
 
 ## MSRV Policy
 
-Serenity's minimum supported Rust version (MSRV) is Rust 1.85.
+Serenity's minimum supported Rust version (MSRV) is Rust 1.88.
 
 We opt to keep MSRV stable on the `current` branch. This means it will remain
 unchanged between minor releases. Occasionally, dependencies may violate SemVer
@@ -244,5 +244,5 @@ a Rust-native cloud development platform that allows deploying Serenity bots for
 [repo:andesite]: https://github.com/natanbc/andesite
 [repo:lavaplayer]: https://github.com/sedmelluq/lavaplayer
 [logo]: https://raw.githubusercontent.com/serenity-rs/serenity/current/logo.png
-[rust-version-badge]: https://img.shields.io/badge/rust-1.85.0+-93450a.svg?style=flat-square
-[rust-version-link]: https://blog.rust-lang.org/2025/02/20/Rust-1.85.0.html
+[rust-version-badge]: https://img.shields.io/badge/rust-1.88.0+-93450a.svg?style=flat-square
+[rust-version-link]: https://blog.rust-lang.org/2025/06/26/Rust-1.88.0.html

examples/e14_message_components/src/main.rs

@@ -17,7 +17,7 @@ use serenity::futures::StreamExt;
 use serenity::model::prelude::*;
 use serenity::prelude::*;
 
-fn sound_button(name: &str, emoji: ReactionType) -> CreateButton {
+fn sound_button(name: &str, emoji: ReactionType) -> CreateButton<'_> {
     // To add an emoji to buttons, use .emoji(). The method accepts anything ReactionType or
     // anything that can be converted to it. For a list of that, search Trait Implementations in
     // the docs for From<...>.

src/builder/create_attachment.rs

@@ -115,7 +115,7 @@ impl<'a> CreateAttachment<'a> {
     /// # Errors
     ///
     /// See [`CreateAttachment::get_data`] for details.
-    pub async fn encode(&self) -> Result<ImageData> {
+    pub async fn encode(&self) -> Result<ImageData<'_>> {
         use base64::engine::{Config, Engine};
 
         const PREFIX: &str = "data:image/png;base64,";
@@ -162,14 +162,15 @@ impl<'a> ImageData<'a> {
     /// docs](https://discord.com/developers/docs/reference#image-data).
     pub fn from_base64(s: impl Into<Cow<'a, str>>) -> Result<Self> {
         let s = s.into();
-        if let Some(("data", tail)) = s.split_once(':') {
-            if let Some((mimetype, encoding)) = tail.split_once(';') {
-                if mimetype.split_once('/').is_some() && encoding.starts_with("base64,") {
-                    return Ok(Self(s));
-                }
-            }
+        if let Some(("data", tail)) = s.split_once(':')
+            && let Some((mimetype, encoding)) = tail.split_once(';')
+            && mimetype.split_once('/').is_some()
+            && encoding.starts_with("base64,")
+        {
+            Ok(Self(s))
+        } else {
+            Err(Error::Url(UrlError::InvalidDataURI))
         }
-        Err(Error::Url(UrlError::InvalidDataURI))
     }
 }
 

src/builder/create_interaction_response.rs

@@ -136,10 +136,10 @@ impl CreateInteractionResponse<'_> {
             _ => Vec::new(),
         };
 
-        if let Self::Message(msg) | Self::Defer(msg) | Self::UpdateMessage(msg) = &mut self {
-            if msg.allowed_mentions.is_none() {
-                msg.allowed_mentions.clone_from(&http.default_allowed_mentions);
-            }
+        if let Self::Message(msg) | Self::Defer(msg) | Self::UpdateMessage(msg) = &mut self
+            && msg.allowed_mentions.is_none()
+        {
+            msg.allowed_mentions.clone_from(&http.default_allowed_mentions);
         }
 
         http.create_interaction_response(interaction_id, interaction_token, &self, files).await

src/builder/edit_message.rs

@@ -230,12 +230,12 @@ impl<'a> EditMessage<'a> {
         self.check_length()?;
 
         #[cfg(feature = "cache")]
-        if let Some(user_id) = user_id {
-            if let Some(cache) = cache_http.cache() {
-                if user_id != cache.current_user().id && !self.is_only_suppress_embeds() {
-                    return Err(Error::Model(ModelError::InvalidUser));
-                }
-            }
+        if let Some(user_id) = user_id
+            && let Some(cache) = cache_http.cache()
+            && user_id != cache.current_user().id
+            && !self.is_only_suppress_embeds()
+        {
+            return Err(Error::Model(ModelError::InvalidUser));
         }
 
         let files = self.attachments.as_ref().map_or(Vec::new(), EditAttachments::new_attachments);

src/cache/event.rs

@@ -88,17 +88,17 @@ impl CacheUpdate for ChannelPinsUpdateEvent {
     type Output = std::convert::Infallible;
 
     fn update(&mut self, cache: &Cache) -> Option<Self::Output> {
-        if let Some(guild_id) = self.guild_id {
-            if let Some(mut guild) = cache.guilds.get_mut(&guild_id) {
-                let (channel_id, thread_id) = self.channel_id.split();
-                if let Some(mut channel) = guild.channels.get_mut(&channel_id) {
-                    channel.base.last_pin_timestamp = self.last_pin_timestamp;
-                    return None;
-                }
+        if let Some(guild_id) = self.guild_id
+            && let Some(mut guild) = cache.guilds.get_mut(&guild_id)
+        {
+            let (channel_id, thread_id) = self.channel_id.split();
+            if let Some(mut channel) = guild.channels.get_mut(&channel_id) {
+                channel.base.last_pin_timestamp = self.last_pin_timestamp;
+                return None;
+            }
 
-                if let Some(mut thread) = guild.threads.get_mut(&thread_id) {
-                    thread.base.last_pin_timestamp = self.last_pin_timestamp;
-                }
+            if let Some(mut thread) = guild.threads.get_mut(&thread_id) {
+                thread.base.last_pin_timestamp = self.last_pin_timestamp;
             }
         }
 
@@ -270,10 +270,10 @@ impl CacheUpdate for GuildRoleUpdateEvent {
     type Output = Role;
 
     fn update(&mut self, cache: &Cache) -> Option<Self::Output> {
-        if let Some(mut guild) = cache.guilds.get_mut(&self.role.guild_id) {
-            if let Some(mut role) = guild.roles.get_mut(&self.role.id) {
-                return Some(std::mem::replace(&mut *role, self.role.clone()));
-            }
+        if let Some(mut guild) = cache.guilds.get_mut(&self.role.guild_id)
+            && let Some(mut role) = guild.roles.get_mut(&self.role.id)
+        {
+            return Some(std::mem::replace(&mut *role, self.role.clone()));
         }
 
         None
@@ -422,39 +422,39 @@ impl CacheUpdate for PresenceUpdateEvent {
     type Output = Presence;
 
     fn update(&mut self, cache: &Cache) -> Option<Presence> {
-        if let Some(guild_id) = self.presence.guild_id {
-            if let Some(mut guild) = cache.guilds.get_mut(&guild_id) {
-                let old = guild.presences.get(&self.presence.user.id).cloned();
-
-                // If the member went offline, remove them from the presence list.
-                if self.presence.status == OnlineStatus::Offline {
-                    guild.presences.remove(&self.presence.user.id);
-                } else {
-                    guild.presences.insert(self.presence.clone());
-                }
+        if let Some(guild_id) = self.presence.guild_id
+            && let Some(mut guild) = cache.guilds.get_mut(&guild_id)
+        {
+            let old = guild.presences.get(&self.presence.user.id).cloned();
 
-                // Create a partial member instance out of the presence update data.
-                if let Some(user) = self.presence.user.to_user() {
-                    if !guild.members.contains_key(&self.presence.user.id) {
-                        guild.members.insert(Member {
-                            guild_id,
-                            joined_at: None,
-                            nick: None,
-                            user,
-                            roles: FixedArray::default(),
-                            premium_since: None,
-                            permissions: None,
-                            avatar: None,
-                            communication_disabled_until: None,
-                            flags: GuildMemberFlags::default(),
-                            unusual_dm_activity_until: None,
-                            __generated_flags: MemberGeneratedFlags::empty(),
-                        });
-                    }
-                }
+            // If the member went offline, remove them from the presence list.
+            if self.presence.status == OnlineStatus::Offline {
+                guild.presences.remove(&self.presence.user.id);
+            } else {
+                guild.presences.insert(self.presence.clone());
+            }
 
-                return old;
+            // Create a partial member instance out of the presence update data.
+            if let Some(user) = self.presence.user.to_user()
+                && !guild.members.contains_key(&self.presence.user.id)
+            {
+                guild.members.insert(Member {
+                    guild_id,
+                    joined_at: None,
+                    nick: None,
+                    user,
+                    roles: FixedArray::default(),
+                    premium_since: None,
+                    permissions: None,
+                    avatar: None,
+                    communication_disabled_until: None,
+                    flags: GuildMemberFlags::default(),
+                    unusual_dm_activity_until: None,
+                    __generated_flags: MemberGeneratedFlags::empty(),
+                });
             }
+
+            return old;
         }
 
         None

src/gateway/client/mod.rs

@@ -300,16 +300,16 @@ impl IntoFuture for ClientBuilder {
         let presence = self.presence;
         let http = self.http;
 
-        if let Some(ratelimiter) = &http.ratelimiter {
-            if let Some(event_handler) = &self.event_handler {
-                let event_handler = Arc::clone(event_handler);
-                ratelimiter.set_ratelimit_callback(Box::new(move |info| {
-                    let event_handler = Arc::clone(&event_handler);
-                    spawn_named("ratelimit::dispatch", async move {
-                        event_handler.ratelimit(info).await;
-                    });
-                }));
-            }
+        if let Some(ratelimiter) = &http.ratelimiter
+            && let Some(event_handler) = &self.event_handler
+        {
+            let event_handler = Arc::clone(event_handler);
+            ratelimiter.set_ratelimit_callback(Box::new(move |info| {
+                let event_handler = Arc::clone(&event_handler);
+                spawn_named("ratelimit::dispatch", async move {
+                    event_handler.ratelimit(info).await;
+                });
+            }));
         }
 
         #[cfg(feature = "cache")]

src/gateway/sharding/mod.rs

@@ -246,13 +246,12 @@ impl Shard {
                 Ok(())
             },
             Err(why) => {
-                if let Error::Tungstenite(err) = &why {
-                    if let TungsteniteError::Io(err) = &**err {
-                        if err.raw_os_error() != Some(32) {
-                            debug!("[{:?}] Err heartbeating: {:?}", self.info, err);
-                            return Err(Error::Gateway(GatewayError::HeartbeatFailed));
-                        }
-                    }
+                if let Error::Tungstenite(err) = &why
+                    && let TungsteniteError::Io(err) = &**err
+                    && err.raw_os_error() != Some(32)
+                {
+                    debug!("[{:?}] Err heartbeating: {:?}", self.info, err);
+                    return Err(Error::Gateway(GatewayError::HeartbeatFailed));
                 }
 
                 warn!("[{:?}] Other err w/ keepalive: {:?}", self.info, why);
@@ -522,10 +521,10 @@ impl Shard {
 
         // If a duration of time less than the heartbeat_interval has passed, then don't perform a
         // keepalive or attempt to reconnect.
-        if let Some(last_sent) = self.last_heartbeat_sent {
-            if last_sent.elapsed() <= heartbeat_interval {
-                return true;
-            }
+        if let Some(last_sent) = self.last_heartbeat_sent
+            && last_sent.elapsed() <= heartbeat_interval
+        {
+            return true;
         }
 
         // If the last heartbeat didn't receive an acknowledgement, then auto-reconnect.
@@ -552,10 +551,11 @@ impl Shard {
     // <https://github.com/abalabahaha/eris/commit/0ce296ae9a542bcec0edf1c999ee2d9986bed5a6>
     #[cfg_attr(feature = "tracing_instrument", instrument(skip(self)))]
     pub fn latency(&self) -> Option<StdDuration> {
-        if let (Some(sent), Some(received)) = (self.last_heartbeat_sent, self.last_heartbeat_ack) {
-            if received > sent {
-                return Some(received - sent);
-            }
+        if let Some(sent) = self.last_heartbeat_sent
+            && let Some(received) = self.last_heartbeat_ack
+            && received > sent
+        {
+            return Some(received - sent);
         }
 
         None