transition Permissions from u64 to SmolBitSet

Cargo.toml

@@ -50,6 +50,7 @@ extract_map = { version = "0.3.0", features = ["serde"] }
 aformat = "0.1.3"
 bytes = "1.5.0"
 ref-cast = "1.0.23"
+smolbitset = { git = "https://github.com/serenity-rs/smolbitset.git", features = ["serde"] }
 # Optional dependencies
 foldhash = { version = "0.1.4", optional = true }
 chrono = { version = "0.4.31", default-features = false, features = ["clock", "serde"], optional = true }
@@ -132,7 +133,7 @@ full = ["default", "collector", "voice", "voice_model", "interactions_endpoint"]
 # Enables temporary caching in functions that retrieve data via the HTTP API.
 temp_cache = ["cache", "mini-moka", "typesize?/mini_moka", "typesize?/dashmap"]
 
-typesize = ["dep:typesize", "dashmap/typesize", "small-fixed-array/typesize", "bool_to_bitflags/typesize", "extract_map/typesize"]
+typesize = ["dep:typesize", "dashmap/typesize", "small-fixed-array/typesize", "bool_to_bitflags/typesize", "extract_map/typesize", "smolbitset/typesize"]
 
 # Enables compile-time heavy instrument macros from tracing
 tracing_instrument = ["tracing/attributes"]

src/builder/bot_auth_parameters.rs

@@ -30,10 +30,9 @@ impl<'a> CreateBotAuthParameters<'a> {
     #[must_use]
     pub fn build(self) -> String {
         // These bindings have to be defined before `valid_data`, due to Drop order.
-        let (client_id_str, guild_id_str, scope_str, bits_str);
+        let (client_id_str, guild_id_str, scope_str, perm_str);
 
         let mut valid_data = ArrayVec::<_, 5>::new();
-        let bits = self.permissions.bits();
 
         if let Some(client_id) = self.client_id {
             client_id_str = client_id.to_arraystring();
@@ -45,9 +44,9 @@ impl<'a> CreateBotAuthParameters<'a> {
             valid_data.push(("scope", &scope_str));
         }
 
-        if bits != 0 {
-            bits_str = bits.to_arraystring();
-            valid_data.push(("permissions", &bits_str));
+        perm_str = self.permissions.to_string();
+        if perm_str != "0" {
+            valid_data.push(("permissions", &perm_str));
         }
 
         if let Some(guild_id) = self.guild_id {

src/builder/edit_role.rs

@@ -43,7 +43,7 @@ pub struct EditRole<'a> {
     #[serde(skip_serializing_if = "Option::is_none")]
     name: Option<Cow<'a, str>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    permissions: Option<u64>,
+    permissions: Option<Permissions>,
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(rename = "color")]
     colour: Option<Colour>,
@@ -78,7 +78,7 @@ impl<'a> EditRole<'a> {
             hoist: Some(role.hoist()),
             mentionable: Some(role.mentionable()),
             name: Some(Cow::Borrowed(&role.name)),
-            permissions: Some(role.permissions.bits()),
+            permissions: Some(role.permissions.clone()),
             position: Some(role.position),
             colour: Some(role.colour),
             unicode_emoji: role.unicode_emoji.as_ref().map(|v| Some(Cow::Borrowed(v.as_str()))),
@@ -122,7 +122,7 @@ impl<'a> EditRole<'a> {
 
     /// Set the role's permissions.
     pub fn permissions(mut self, permissions: Permissions) -> Self {
-        self.permissions = Some(permissions.bits());
+        self.permissions = Some(permissions);
         self
     }
 
@@ -204,11 +204,7 @@ pub struct CreateRoleColours {
 
 impl CreateRoleColours {
     pub fn new(primary_colour: Colour) -> Self {
-        Self {
-            primary_color: primary_colour,
-            secondary_color: None,
-            tertiary_color: None,
-        }
+        Self { primary_color: primary_colour, secondary_color: None, tertiary_color: None }
     }
 
     /// Sets the secondary colour for this role.

src/model/application/interaction.rs

@@ -3,10 +3,7 @@ use serde::ser::{Serialize, Serializer};
 use serde_json::value::RawValue;
 
 use super::{
-    CommandInteraction,
-    ComponentInteraction,
-    InstallationContext,
-    ModalInteraction,
+    CommandInteraction, ComponentInteraction, InstallationContext, ModalInteraction,
     PingInteraction,
 };
 use crate::internal::prelude::*;
@@ -60,10 +57,10 @@ impl Interaction {
     #[must_use]
     pub fn app_permissions(&self) -> Permissions {
         match self {
-            Self::Ping(i) => i.app_permissions,
-            Self::Command(i) | Self::Autocomplete(i) => i.app_permissions,
-            Self::Component(i) => i.app_permissions,
-            Self::Modal(i) => i.app_permissions,
+            Self::Ping(i) => i.app_permissions.clone(),
+            Self::Command(i) | Self::Autocomplete(i) => i.app_permissions.clone(),
+            Self::Component(i) => i.app_permissions.clone(),
+            Self::Modal(i) => i.app_permissions.clone(),
         }
     }
 
@@ -525,10 +522,7 @@ impl serde::Serialize for MessageInteractionMetadata {
             val: T,
             kind: InteractionType,
         ) -> StdResult<S::Ok, S::Error> {
-            let wrapper = WithType {
-                kind,
-                val,
-            };
+            let wrapper = WithType { kind, val };
 
             wrapper.serialize(serializer)
         }

src/model/channel/message.rs

@@ -238,7 +238,7 @@ impl Message {
         };
 
         if is_thread {
-            permissions.set(Permissions::SEND_MESSAGES, permissions.send_messages_in_threads());
+            permissions.set(Permission::SEND_MESSAGES, permissions.send_messages_in_threads());
         }
 
         Some(permissions)
@@ -813,13 +813,7 @@ pub struct MessageReference {
 impl MessageReference {
     #[must_use]
     pub fn new(kind: MessageReferenceKind, channel_id: GenericChannelId) -> Self {
-        Self {
-            kind,
-            channel_id,
-            message_id: None,
-            guild_id: None,
-            fail_if_not_exists: None,
-        }
+        Self { kind, channel_id, message_id: None, guild_id: None, fail_if_not_exists: None }
     }
 
     #[must_use]
@@ -988,11 +982,7 @@ pub struct MessageLink {
 impl Display for MessageLink {
     #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let MessageLink {
-            message_id,
-            channel_id,
-            guild_id,
-        } = self;
+        let MessageLink { message_id, channel_id, guild_id } = self;
 
         f.write_str("https://discord.com/channels")?;
         if let Some(guild_id) = guild_id {
@@ -1009,11 +999,7 @@ impl MessageId {
     /// link will be valid for messages in either private channels or guilds.
     #[must_use]
     pub fn link(self, channel_id: GenericChannelId, guild_id: Option<GuildId>) -> MessageLink {
-        MessageLink {
-            message_id: self,
-            channel_id,
-            guild_id,
-        }
+        MessageLink { message_id: self, channel_id, guild_id }
     }
 }
 
@@ -1200,15 +1186,8 @@ mod tests {
     use small_fixed_array::FixedArray;
 
     use super::{
-        Guild,
-        GuildChannel,
-        Member,
-        Message,
-        PermissionOverwrite,
-        PermissionOverwriteType,
-        Permissions,
-        User,
-        UserId,
+        Guild, GuildChannel, Member, Message, PermissionOverwrite, PermissionOverwriteType,
+        Permissions, User, UserId,
     };
     use crate::cache::Cache;
     use crate::model::event::GuildCreateEvent;
@@ -1227,10 +1206,7 @@ mod tests {
     #[test]
     fn author_permissions_respects_overwrites() {
         // Author of the message, with a random ID that won't collide with defaults.
-        let author = User {
-            id: UserId::new(50778944701071),
-            ..Default::default()
-        };
+        let author = User { id: UserId::new(50778944701071), ..Default::default() };
 
         // Channel with the message, with SEND_MESSAGES on.
         let channel = GuildChannel {
@@ -1246,26 +1222,17 @@ mod tests {
         // Guild with the author and channel cached, default (empty) permissions.
         let guild = Guild {
             channels: new_extract_map(channel),
-            members: new_extract_map(Member {
-                user: author.clone(),
-                ..Default::default()
-            }),
+            members: new_extract_map(Member { user: author.clone(), ..Default::default() }),
             ..Default::default()
         };
 
         // Message, tied to the guild and the channel.
-        let message = Message {
-            author,
-            channel_id,
-            guild_id: Some(guild.id),
-            ..Default::default()
-        };
+        let message =
+            Message { author, channel_id, guild_id: Some(guild.id), ..Default::default() };
 
         // Cache, with the guild setup.
         let cache = Cache::new();
-        cache.update(&mut GuildCreateEvent {
-            guild,
-        });
+        cache.update(&mut GuildCreateEvent { guild });
 
         // The author should only have the one permission, SEND_MESSAGES.
         assert_eq!(message.author_permissions(&cache), Some(Permissions::SEND_MESSAGES));

src/model/guild/mod.rs

@@ -273,7 +273,7 @@ impl Guild {
                     .members
                     .iter()
                     .map(|member| self.user_permissions_in(channel, member))
-                    .all(Permissions::view_channel)
+                    .all(|perm| Permissions::view_channel(&perm))
         })
     }
 
@@ -320,10 +320,7 @@ impl Guild {
             icon: Option<ImageHash>,
         }
 
-        let body = CreateGuild {
-            name,
-            icon,
-        };
+        let body = CreateGuild { name, icon };
 
         #[expect(deprecated)]
         http.create_guild(&body).await
@@ -894,17 +891,17 @@ impl Guild {
                 match overwrite.kind {
                     PermissionOverwriteType::Member(user_id) => {
                         if member_user_id == user_id {
-                            member_allow_overwrites = overwrite.allow;
-                            member_deny_overwrites = overwrite.deny;
+                            member_allow_overwrites = overwrite.allow.clone();
+                            member_deny_overwrites = overwrite.deny.clone();
                         }
                     },
                     PermissionOverwriteType::Role(role_id) => {
                         if role_id.get() == guild_id.get() {
-                            everyone_allow_overwrites = overwrite.allow;
-                            everyone_deny_overwrites = overwrite.deny;
+                            everyone_allow_overwrites = overwrite.allow.clone();
+                            everyone_deny_overwrites = overwrite.deny.clone();
                         } else if member_roles.contains(&role_id) {
-                            roles_allow_overwrites.push(overwrite.allow);
-                            roles_deny_overwrites.push(overwrite.deny);
+                            roles_allow_overwrites.push(overwrite.allow.clone());
+                            roles_deny_overwrites.push(overwrite.deny.clone());
                         }
                     },
                 }
@@ -915,7 +912,7 @@ impl Guild {
             is_guild_owner: member_user_id == guild_owner_id,
             everyone_permissions: if let Some(role) = guild_roles.get(&RoleId::new(guild_id.get()))
             {
-                role.permissions
+                role.permissions.clone()
             } else {
                 error!("@everyone role missing in {}", guild_id);
                 Permissions::empty()
@@ -924,7 +921,7 @@ impl Guild {
                 .iter()
                 .map(|role_id| {
                     if let Some(role) = guild_roles.get(role_id) {
-                        role.permissions
+                        role.permissions.clone()
                     } else {
                         warn!(
                             "{} on {} has non-existent role {:?}",
@@ -1043,7 +1040,7 @@ fn calculate_permissions(data: CalculatePermissions) -> Permissions {
     }
 
     // 3. Overwrites that deny permissions for @everyone are applied at a channel level
-    permissions &= !data.everyone_deny_overwrites;
+    permissions.and_not_assign(&data.everyone_deny_overwrites);
     // 4. Overwrites that allow permissions for @everyone are applied at a channel level
     permissions |= data.everyone_allow_overwrites;
 
@@ -1052,7 +1049,7 @@ fn calculate_permissions(data: CalculatePermissions) -> Permissions {
     for p in data.roles_deny_overwrites {
         role_deny_permissions |= p;
     }
-    permissions &= !role_deny_permissions;
+    permissions.and_not_assign(&role_deny_permissions);
 
     // 6. Overwrites that allow permissions for specific roles are applied at a channel level
     let mut role_allow_permissions = Permissions::empty();
@@ -1062,7 +1059,7 @@ fn calculate_permissions(data: CalculatePermissions) -> Permissions {
     permissions |= role_allow_permissions;
 
     // 7. Member-specific overwrites that deny permissions are applied at a channel level
-    permissions &= !data.member_deny_overwrites;
+    permissions.and_not_assign(&data.member_deny_overwrites);
     // 8. Member-specific overwrites that allow permissions are applied at a channel level
     permissions |= data.member_allow_overwrites;
 
@@ -1331,10 +1328,7 @@ mod test {
         fn get_guild() -> Guild {
             let m = get_member();
 
-            Guild {
-                members: ExtractMap::from_iter([m]),
-                ..Default::default()
-            }
+            Guild { members: ExtractMap::from_iter([m]), ..Default::default() }
         }
 
         #[test]