Split GuildThread from GuildChannel (#3026)

Author: GnomedDev

Cargo.toml

@@ -49,6 +49,7 @@ to-arraystring = "0.2.0"
 extract_map = { version = "0.2.0", features = ["serde", "iter_mut"] }
 aformat = "0.1.3"
 bytes = "1.5.0"
+ref-cast = "1.0.23"
 # Optional dependencies
 foldhash = { version = "0.1.4", optional = true }
 chrono = { version = "0.4.31", default-features = false, features = ["clock", "serde"], optional = true }

examples/e12_parallel_loops/src/main.rs

@@ -5,7 +5,7 @@ use chrono::offset::Utc;
 use serenity::async_trait;
 use serenity::builder::{CreateEmbed, CreateMessage};
 use serenity::gateway::ActivityData;
-use serenity::model::id::ChannelId;
+use serenity::model::id::GenericChannelId;
 use serenity::prelude::*;
 
 struct Handler {
@@ -93,7 +93,7 @@ async fn log_system_load(ctx: &Context) {
             false,
         );
     let builder = CreateMessage::new().embed(embed);
-    let message = ChannelId::new(381926291785383946).send_message(&ctx.http, builder).await;
+    let message = GenericChannelId::new(381926291785383946).send_message(&ctx.http, builder).await;
     if let Err(why) = message {
         eprintln!("Error sending message: {why:?}");
     };

examples/testing/src/main.rs

@@ -87,7 +87,8 @@ async fn message(ctx: &Context, msg: &Message) -> Result<(), serenity::Error> {
         model_type_sizes::print_ranking();
     } else if msg.content == "auditlog" {
         // Test special characters in audit log reason
-        msg.channel_id
+        channel_id
+            .expect_channel()
             .edit(
                 &ctx.http,
                 EditChannel::new().name("new-channel-name").audit_log_reason("hello\nworld\n🙂"),
@@ -155,6 +156,7 @@ async fn message(ctx: &Context, msg: &Message) -> Result<(), serenity::Error> {
         guild_id.ban(&ctx.http, user_id, 0, None).await?;
     } else if msg.content == "createtags" {
         channel_id
+            .expect_channel()
             .edit(
                 &ctx.http,
                 EditChannel::new().available_tags(vec![
@@ -165,9 +167,10 @@ async fn message(ctx: &Context, msg: &Message) -> Result<(), serenity::Error> {
             .await?;
     } else if msg.content == "assigntags" {
         let forum_id = msg.guild_channel(&ctx).await?.parent_id.unwrap();
-        let forum = forum_id.to_guild_channel(&ctx, msg.guild_id).await?;
+        let forum = forum_id.widen().to_guild_channel(&ctx, msg.guild_id).await?;
         channel_id
-            .edit_thread(
+            .expect_thread()
+            .edit(
                 &ctx.http,
                 EditThread::new()
                     .applied_tags(forum.available_tags.iter().map(|t| t.id).collect::<Vec<_>>()),
@@ -199,7 +202,7 @@ async fn message(ctx: &Context, msg: &Message) -> Result<(), serenity::Error> {
         msg.author.id.dm(&ctx.http, builder).await?;
     } else if let Some(channel) = msg.content.strip_prefix("movetorootandback") {
         let mut channel = {
-            let channel_id = channel.trim().parse::<ChannelId>().unwrap();
+            let channel_id = channel.trim().parse::<GenericChannelId>().unwrap();
             channel_id.to_guild_channel(&ctx, msg.guild_id).await.unwrap()
         };
 

examples/testing/src/model_type_sizes.rs

@@ -65,6 +65,7 @@ pub fn print_ranking() {
         ("GuildBanAddEvent", std::mem::size_of::<GuildBanAddEvent>()),
         ("GuildBanRemoveEvent", std::mem::size_of::<GuildBanRemoveEvent>()),
         ("GuildChannel", std::mem::size_of::<GuildChannel>()),
+        ("GuildThread", std::mem::size_of::<GuildThread>()),
         ("GuildCreateEvent", std::mem::size_of::<GuildCreateEvent>()),
         ("GuildDeleteEvent", std::mem::size_of::<GuildDeleteEvent>()),
         ("GuildEmojisUpdateEvent", std::mem::size_of::<GuildEmojisUpdateEvent>()),
@@ -131,10 +132,12 @@ pub fn print_ranking() {
         ("ModalInteraction", std::mem::size_of::<ModalInteraction>()),
         ("ModalInteractionData", std::mem::size_of::<ModalInteractionData>()),
         ("AuditLogEntryOptions", std::mem::size_of::<AuditLogEntryOptions>()),
-        ("PartialChannel", std::mem::size_of::<PartialChannel>()),
+        ("GenericInteractionChannel", std::mem::size_of::<GenericInteractionChannel>()),
+        ("InteractionChannel", std::mem::size_of::<InteractionChannel>()),
+        ("InteractionGuildThread", std::mem::size_of::<InteractionGuildThread>()),
         ("PartialCurrentApplicationInfo", std::mem::size_of::<PartialCurrentApplicationInfo>()),
         ("PartialGuild", std::mem::size_of::<PartialGuild>()),
-        ("PartialGuildChannel", std::mem::size_of::<PartialGuildChannel>()),
+        ("PartialGuildThread", std::mem::size_of::<PartialGuildThread>()),
         ("PartialMember", std::mem::size_of::<PartialMember>()),
         ("PermissionOverwrite", std::mem::size_of::<PermissionOverwrite>()),
         ("Permissions", std::mem::size_of::<Permissions>()),

src/builder/create_allowed_mentions.rs

@@ -24,8 +24,7 @@ impl ParseAction {
     }
 }
 
-/// A builder to manage the allowed mentions on a message, used by the [`ChannelId::send_message`]
-/// and [`ChannelId::edit_message`] methods.
+/// A builder to manage the allowed mentions on a message.
 ///
 /// # Examples
 ///

src/builder/create_components.rs

@@ -224,7 +224,7 @@ pub enum CreateSelectMenuKind<'a> {
     },
     Channel {
         channel_types: Option<Cow<'a, [ChannelType]>>,
-        default_channels: Option<Cow<'a, [ChannelId]>>,
+        default_channels: Option<Cow<'a, [GenericChannelId]>>,
     },
 }
 

src/builder/create_embed.rs

@@ -185,12 +185,11 @@ impl<'a> CreateEmbed<'a> {
 
     /// Same as calling [`Self::image`] with "attachment://filename.(jpg, png)".
     ///
-    /// Note however, you have to be sure you set an attachment (with [`ChannelId::send_files`])
-    /// with the provided filename. Or else this won't work.
+    /// Remember to set an attachment with the provided filename via [`CreateAttachment`]
     ///
     /// Refer [`Self::image`] for rules on naming local attachments.
     ///
-    /// [`ChannelId::send_files`]: crate::model::id::ChannelId::send_files
+    /// [`CreateAttachment`]: crate::builder::CreateAttachment
     pub fn attachment(self, filename: impl Into<String>) -> Self {
         let mut filename = filename.into();
         filename.insert_str(0, "attachment://");

src/builder/create_message.rs

@@ -16,7 +16,7 @@ use crate::internal::prelude::*;
 use crate::model::prelude::*;
 
 /// A builder to specify the contents of an send message request, primarily meant for use
-/// through [`ChannelId::send_message`].
+/// through [`GenericChannelId::send_message`].
 ///
 /// There are three situations where different field requirements are present:
 ///
@@ -27,21 +27,21 @@ use crate::model::prelude::*;
 ///    required.
 ///
 /// Note that if you only need to send the content of a message, without specifying other fields,
-/// then [`ChannelId::say`] may be a more preferable option.
+/// then [`GenericChannelId::say`] may be a more preferable option.
 ///
 /// # Examples
 ///
 /// Sending a message with a content of `"test"` and applying text-to-speech:
 ///
 /// ```rust,no_run
 /// use serenity::builder::{CreateEmbed, CreateMessage};
-/// use serenity::model::id::ChannelId;
+/// use serenity::model::id::GenericChannelId;
 /// # use serenity::http::Http;
 /// # use std::sync::Arc;
 /// #
 /// # async fn run() {
 /// # let http: Arc<Http> = unimplemented!();
-/// # let channel_id = ChannelId::new(7);
+/// # let channel_id = GenericChannelId::new(7);
 /// let embed = CreateEmbed::new().title("This is an embed").description("With a description");
 /// let builder = CreateMessage::new().content("test").tts(true).embed(embed);
 /// let _ = channel_id.send_message(&http, builder).await;
@@ -290,7 +290,7 @@ impl<'a> CreateMessage<'a> {
     pub async fn execute(
         mut self,
         http: &Http,
-        channel_id: ChannelId,
+        channel_id: GenericChannelId,
         guild_id: Option<GuildId>,
     ) -> Result<Message> {
         self.check_length()?;

src/builder/create_scheduled_event.rs

@@ -131,8 +131,8 @@ impl<'a> CreateScheduledEvent<'a> {
     ///
     /// [Create Events]: Permissions::CREATE_EVENTS
     #[cfg(feature = "http")]
-    pub async fn execute(self, http: &Http, channel_id: GuildId) -> Result<ScheduledEvent> {
-        http.create_scheduled_event(channel_id, &self, self.audit_log_reason).await
+    pub async fn execute(self, http: &Http, guild_id: GuildId) -> Result<ScheduledEvent> {
+        http.create_scheduled_event(guild_id, &self, self.audit_log_reason).await
     }
 }
 

src/builder/edit_channel.rs

@@ -331,6 +331,9 @@ impl<'a> EditChannel<'a> {
             .await?;
         }
 
-        http.edit_channel(channel_id, &self, self.audit_log_reason).await
+        http.edit_channel(channel_id.widen(), &self, self.audit_log_reason)
+            .await?
+            .guild()
+            .ok_or(Error::Model(ModelError::InvalidChannelType))
     }
 }