Fix breakage caused by builder trait removal

examples/feature_showcase/collector.rs

@@ -38,7 +38,7 @@ pub async fn boop(ctx: Context<'_>) -> Result<(), Error> {
         )
         .await?;
 
-        mci.create_response(ctx, serenity::CreateInteractionResponse::Acknowledge)
+        mci.create_response(ctx.http(), serenity::CreateInteractionResponse::Acknowledge)
             .await?;
     }
 

examples/manual_dispatch/main.rs

@@ -20,17 +20,30 @@ struct Handler {
 }
 #[serenity::async_trait]
 impl serenity::EventHandler for Handler {
-    async fn message(&self, ctx: serenity::Context, new_message: serenity::Message) {
+    async fn message(&self, serenity_context: &serenity::Context, new_message: &serenity::Message) {
         // FrameworkContext contains all data that poise::Framework usually manages
         let shard_manager = (*self.shard_manager.lock().unwrap()).clone().unwrap();
         let framework_data = poise::FrameworkContext {
-            serenity_context: &ctx,
+            serenity_context,
             options: &self.options,
             shard_manager: &shard_manager,
         };
 
-        let event = serenity::FullEvent::Message { new_message };
-        poise::dispatch_event(framework_data, event).await;
+        let invocation_data = tokio::sync::Mutex::new(Box::new(()) as _);
+        let trigger = poise::MessageDispatchTrigger::MessageCreate;
+        let mut parent_commands = Vec::new();
+
+        let res = poise::dispatch_message(
+            framework_data,
+            new_message,
+            trigger,
+            &invocation_data,
+            &mut parent_commands,
+        );
+
+        if let Err(err) = res.await {
+            err.handle(&self.options).await;
+        }
     }
 
     // For slash commands or edit tracking to work, forward interaction_create and message_update

src/builtins/paginate.rs

@@ -83,7 +83,7 @@ pub async fn paginate<U: Send + Sync + 'static, E>(
         // Update the message with the new page contents
         press
             .create_response(
-                ctx.serenity_context(),
+                ctx.http(),
                 serenity::CreateInteractionResponse::UpdateMessage(
                     serenity::CreateInteractionResponseMessage::new()
                         .embed(serenity::CreateEmbed::new().description(pages[current_page])),

src/dispatch/mod.rs

@@ -66,9 +66,9 @@ impl<'a, U: Send + Sync + 'static, E> FrameworkContext<'a, U, E> {
 /// Central event handling function of this library
 pub async fn dispatch_event<U: Send + Sync + 'static, E>(
     framework: crate::FrameworkContext<'_, U, E>,
-    event: serenity::FullEvent,
+    event: &serenity::FullEvent,
 ) {
-    match &event {
+    match event {
         serenity::FullEvent::Message { new_message } => {
             let invocation_data = tokio::sync::Mutex::new(Box::new(()) as _);
             let mut parent_commands = Vec::new();
@@ -172,10 +172,10 @@ pub async fn dispatch_event<U: Send + Sync + 'static, E>(
 
     // Do this after the framework's Ready handling, so that get_user_data() doesnt
     // potentially block infinitely
-    if let Err(error) = (framework.options.event_handler)(framework, &event).await {
+    if let Err(error) = (framework.options.event_handler)(framework, event).await {
         let error = crate::FrameworkError::EventHandler {
             error,
-            event: &event,
+            event,
             framework,
         };
         (framework.options.on_error)(error).await;

src/dispatch/slash.rs

@@ -236,7 +236,7 @@ async fn run_autocomplete<U: Send + Sync + 'static, E>(
     if let Err(e) = ctx
         .interaction
         .create_response(
-            &ctx.framework.serenity_context,
+            ctx.http(),
             serenity::CreateInteractionResponse::Autocomplete(autocomplete_response),
         )
         .await

src/framework/mod.rs

@@ -107,7 +107,7 @@ impl<U: Send + Sync + 'static, E: Send + Sync> serenity::Framework for Framework
         }
     }
 
-    async fn dispatch(&self, ctx: serenity::Context, event: serenity::FullEvent) {
+    async fn dispatch(&self, ctx: &serenity::Context, event: &serenity::FullEvent) {
         raw_dispatch_event(self, ctx, event).await
     }
 }
@@ -116,12 +116,12 @@ impl<U: Send + Sync + 'static, E: Send + Sync> serenity::Framework for Framework
 /// Otherwise, it forwards the event to [`crate::dispatch_event`]
 async fn raw_dispatch_event<U, E>(
     framework: &Framework<U, E>,
-    ctx: serenity::Context,
-    event: serenity::FullEvent,
+    serenity_context: &serenity::Context,
+    event: &serenity::FullEvent,
 ) where
     U: Send + Sync + 'static,
 {
-    if let serenity::FullEvent::Ready { data_about_bot } = &event {
+    if let serenity::FullEvent::Ready { data_about_bot } = event {
         let _: Result<_, _> = framework.bot_id.set(data_about_bot.user.id);
     }
 
@@ -133,7 +133,7 @@ async fn raw_dispatch_event<U, E>(
     let framework = crate::FrameworkContext {
         #[cfg(not(feature = "cache"))]
         bot_id,
-        serenity_context: &ctx,
+        serenity_context,
         options: &framework.options,
         shard_manager: framework.shard_manager(),
     };

src/modal.rs

@@ -65,7 +65,7 @@ async fn execute_modal_generic<
 
     // Send acknowledgement so that the pop-up is closed
     response
-        .create_response(ctx, serenity::CreateInteractionResponse::Acknowledge)
+        .create_response(&ctx.http, serenity::CreateInteractionResponse::Acknowledge)
         .await?;
 
     Ok(Some(M::parse(response.data)))
@@ -94,7 +94,7 @@ pub async fn execute_modal<U: Send + Sync + 'static, E, M: Modal>(
     let interaction = ctx.interaction;
     let response = execute_modal_generic(
         ctx.serenity_context(),
-        |resp| interaction.create_response(ctx, resp),
+        |resp| interaction.create_response(ctx.http(), resp),
         interaction.id.to_string(),
         defaults,
         timeout,
@@ -125,7 +125,7 @@ pub async fn execute_modal_on_component_interaction<M: Modal>(
 ) -> Result<Option<M>, serenity::Error> {
     execute_modal_generic(
         ctx,
-        |resp| interaction.create_response(ctx, resp),
+        |resp| interaction.create_response(&ctx.http, resp),
         interaction.id.to_string(),
         defaults,
         timeout,

src/reply/send_reply.rs

@@ -76,17 +76,15 @@ where
             let builder = builder
                 .to_slash_followup_response(serenity::CreateInteractionResponseFollowup::new());
 
-            ctx.interaction
-                .create_followup(ctx.serenity_context(), builder)
-                .await?
+            ctx.interaction.create_followup(ctx.http(), builder).await?
         }))
     } else {
         let builder =
             builder.to_slash_initial_response(serenity::CreateInteractionResponseMessage::new());
 
         ctx.interaction
             .create_response(
-                ctx.serenity_context(),
+                ctx.http(),
                 serenity::CreateInteractionResponse::Message(builder),
             )
             .await?;

src/structs/slash.rs

@@ -68,9 +68,8 @@ impl<U, E> ApplicationContext<'_, U, E> {
                 serenity::CreateInteractionResponseMessage::new().ephemeral(ephemeral),
             );
 
-            self.interaction
-                .create_response(self.framework.serenity_context, response)
-                .await?;
+            let http = &self.framework.serenity_context.http;
+            self.interaction.create_response(http, response).await?;
 
             self.has_sent_initial_response
                 .store(true, std::sync::atomic::Ordering::SeqCst);