Port poise to use serenity data generic

Cargo.toml

@@ -21,7 +21,8 @@ parking_lot = "0.12.1"
 [dependencies.serenity]
 default-features = false
 features = ["builder", "client", "gateway", "model", "utils", "collector", "framework"]
-version = "0.12.0"
+git = "https://github.com/gnomeddev/serenity"
+branch = "typemap-be-gone"
 
 [dev-dependencies]
 # For the examples

examples/advanced_cooldowns/main.rs

@@ -41,14 +41,15 @@ async fn main() {
         .setup(|ctx, _ready, framework| {
             Box::pin(async move {
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                Ok(Data {})
+                Ok(())
             })
         })
         .build();
 
-    let client = serenity::Client::builder(token, serenity::GatewayIntents::non_privileged())
-        .framework(framework)
-        .await;
+    let client =
+        serenity::Client::builder(token, serenity::GatewayIntents::non_privileged(), Data {})
+            .framework(framework)
+            .await;
 
     client.unwrap().start().await.unwrap();
 }

examples/basic_structure/main.rs

@@ -81,7 +81,7 @@ async fn main() {
         // Enforce command checks even for owners (enforced by default)
         // Set to true to bypass checks, which is useful for testing
         skip_checks_for_owners: false,
-        event_handler: |_ctx, event, _framework, _data| {
+        event_handler: |_ctx, event, _framework| {
             Box::pin(async move {
                 println!(
                     "Got an event in event handler: {:?}",
@@ -93,14 +93,16 @@ async fn main() {
         ..Default::default()
     };
 
+    let data = Data {
+        votes: Mutex::new(HashMap::new()),
+    };
+
     let framework = poise::Framework::builder()
         .setup(move |ctx, _ready, framework| {
             Box::pin(async move {
                 println!("Logged in as {}", _ready.user.name);
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                Ok(Data {
-                    votes: Mutex::new(HashMap::new()),
-                })
+                Ok(())
             })
         })
         .options(options)
@@ -111,7 +113,7 @@ async fn main() {
     let intents =
         serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, data)
         .framework(framework)
         .await;
 

examples/event_handler/main.rs

@@ -17,48 +17,42 @@ pub struct Data {
 async fn main() {
     env_logger::init();
 
+    let data = Data {
+        poise_mentions: AtomicU32::new(0),
+    };
+
     let token = var("DISCORD_TOKEN")
         .expect("Missing `DISCORD_TOKEN` env var, see README for more information.");
     let intents =
         serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
 
     let framework = poise::Framework::builder()
-        .setup(move |_ctx, _ready, _framework| {
-            Box::pin(async move {
-                Ok(Data {
-                    poise_mentions: AtomicU32::new(0),
-                })
-            })
-        })
         .options(poise::FrameworkOptions {
-            event_handler: |ctx, event, framework, data| {
-                Box::pin(event_handler(ctx, event, framework, data))
-            },
+            event_handler: |ctx, event, framework| Box::pin(event_handler(ctx, event, framework)),
             ..Default::default()
         })
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, data)
         .framework(framework)
         .await;
 
     client.unwrap().start().await.unwrap();
 }
 
 async fn event_handler(
-    ctx: &serenity::Context,
+    ctx: &serenity::Context<Data>,
     event: &serenity::FullEvent,
     _framework: poise::FrameworkContext<'_, Data, Error>,
-    data: &Data,
 ) -> Result<(), Error> {
     match event {
         serenity::FullEvent::Ready { data_about_bot, .. } => {
             println!("Logged in as {}", data_about_bot.user.name);
         }
         serenity::FullEvent::Message { new_message } => {
             if new_message.content.to_lowercase().contains("poise") {
-                let mentions = data.poise_mentions.load(Ordering::SeqCst) + 1;
-                data.poise_mentions.store(mentions, Ordering::SeqCst);
+                let mentions = ctx.data.poise_mentions.load(Ordering::SeqCst) + 1;
+                ctx.data.poise_mentions.store(mentions, Ordering::SeqCst);
                 new_message
                     .reply(ctx, format!("Poise has been mentioned {} times", mentions))
                     .await?;

examples/feature_showcase/main.rs

@@ -94,7 +94,7 @@ async fn main() {
         .setup(move |ctx, _ready, framework| {
             Box::pin(async move {
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                Ok(Data {})
+                Ok(())
             })
         })
         .build();
@@ -103,7 +103,7 @@ async fn main() {
     let intents =
         serenity::GatewayIntents::non_privileged() | serenity::GatewayIntents::MESSAGE_CONTENT;
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, Data {})
         .framework(framework)
         .await;
 

examples/feature_showcase/modal.rs

@@ -43,7 +43,8 @@ pub async fn component_modal(ctx: crate::Context<'_>) -> Result<(), Error> {
         .await
     {
         let data =
-            poise::execute_modal_on_component_interaction::<MyModal>(ctx, mci, None, None).await?;
+            poise::execute_modal_on_component_interaction::<MyModal, _>(ctx, mci, None, None)
+                .await?;
         println!("Got data: {:?}", data);
     }
     Ok(())

examples/fluent_localization/main.rs

@@ -72,10 +72,9 @@ async fn main() {
             commands,
             ..Default::default()
         })
-        .setup(move |_, _, _| Box::pin(async move { Ok(Data { translations }) }))
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, Data { translations })
         .framework(framework)
         .await;
 

examples/generic_commands/main.rs

@@ -4,7 +4,7 @@
 //! The original use case for this feature was to have the same command in two different bots
 
 #[poise::command(slash_command)]
-pub async fn example<U: Sync, E>(ctx: poise::Context<'_, U, E>) -> Result<(), E> {
+pub async fn example<U: Sync + Send, E>(ctx: poise::Context<'_, U, E>) -> Result<(), E> {
     ctx.say(format!(
         "My user data type is {} and the error type is {}",
         std::any::type_name::<U>(),

examples/help_generation/main.rs

@@ -345,12 +345,12 @@ async fn main() {
         .setup(|ctx, _ready, framework| {
             Box::pin(async move {
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                Ok(Data {})
+                Ok(())
             })
         })
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, Data {})
         .framework(framework)
         .await;
 

examples/invocation_data/main.rs

@@ -121,7 +121,7 @@ async fn main() {
         })
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, ())
         .framework(framework)
         .await;
 

examples/manual_dispatch/main.rs

@@ -6,6 +6,7 @@
 
 use poise::serenity_prelude as serenity;
 
+type Data = ();
 type Error = serenity::Error;
 
 #[poise::command(prefix_command)]
@@ -19,14 +20,13 @@ struct Handler {
     shard_manager: std::sync::Mutex<Option<std::sync::Arc<serenity::ShardManager>>>,
 }
 #[serenity::async_trait]
-impl serenity::EventHandler for Handler {
-    async fn message(&self, ctx: serenity::Context, new_message: serenity::Message) {
+impl serenity::EventHandler<Data> for Handler {
+    async fn message(&self, ctx: serenity::Context<Data>, 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 {
             bot_id: serenity::UserId::new(846453852164587620),
             options: &self.options,
-            user_data: &(),
             shard_manager: &shard_manager,
         };
 
@@ -51,7 +51,7 @@ async fn main() -> Result<(), Error> {
     poise::set_qualified_names(&mut handler.options.commands); // some setup
 
     let handler = std::sync::Arc::new(handler);
-    let mut client = serenity::Client::builder(token, intents)
+    let mut client = serenity::Client::builder(token, intents, ())
         .event_handler_arc(handler.clone())
         .await?;
 

examples/quickstart/main.rs

@@ -29,12 +29,12 @@ async fn main() {
         .setup(|ctx, _ready, framework| {
             Box::pin(async move {
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
-                Ok(Data {})
+                Ok(())
             })
         })
         .build();
 
-    let client = serenity::ClientBuilder::new(token, intents)
+    let client = serenity::ClientBuilder::new(token, intents, Data {})
         .framework(framework)
         .await;
     client.unwrap().start().await.unwrap();

src/builtins/help.rs

@@ -85,7 +85,9 @@ impl TwoColumnList {
 }
 
 /// Get the prefix from options
-async fn get_prefix_from_options<U, E>(ctx: crate::Context<'_, U, E>) -> Option<String> {
+async fn get_prefix_from_options<U: Send + Sync + 'static, E>(
+    ctx: crate::Context<'_, U, E>,
+) -> Option<String> {
     let options = &ctx.framework().options().prefix_options;
     match &options.prefix {
         Some(fixed_prefix) => Some(fixed_prefix.clone()),
@@ -102,7 +104,9 @@ async fn get_prefix_from_options<U, E>(ctx: crate::Context<'_, U, E>) -> Option<
 }
 
 /// Format context menu command name
-fn format_context_menu_name<U, E>(command: &crate::Command<U, E>) -> Option<String> {
+fn format_context_menu_name<U: Send + Sync + 'static, E>(
+    command: &crate::Command<U, E>,
+) -> Option<String> {
     let kind = match command.context_menu_action {
         Some(crate::ContextMenuCommandAction::User(_)) => "user",
         Some(crate::ContextMenuCommandAction::Message(_)) => "message",
@@ -120,7 +124,7 @@ fn format_context_menu_name<U, E>(command: &crate::Command<U, E>) -> Option<Stri
 }
 
 /// Code for printing help of a specific command (e.g. `~help my_command`)
-async fn help_single_command<U, E>(
+async fn help_single_command<U: Send + Sync + 'static, E>(
     ctx: crate::Context<'_, U, E>,
     command_name: &str,
     config: HelpConfiguration<'_>,
@@ -234,7 +238,7 @@ async fn help_single_command<U, E>(
 }
 
 /// Recursively formats all subcommands
-fn preformat_subcommands<U, E>(
+fn preformat_subcommands<U: Send + Sync + 'static, E>(
     commands: &mut TwoColumnList,
     command: &crate::Command<U, E>,
     prefix: &str,
@@ -259,7 +263,7 @@ fn preformat_subcommands<U, E>(
 }
 
 /// Preformat lines (except for padding,) like `("  /ping", "Emits a ping message")`
-fn preformat_command<U, E>(
+fn preformat_command<U: Send + Sync + 'static, E>(
     commands: &mut TwoColumnList,
     config: &HelpConfiguration<'_>,
     command: &crate::Command<U, E>,
@@ -289,7 +293,7 @@ fn preformat_command<U, E>(
 /// Create help text for `help_all_commands`
 ///
 /// This is a separate function so we can have tests for it
-async fn generate_all_commands<U, E>(
+async fn generate_all_commands<U: Send + Sync + 'static, E>(
     ctx: crate::Context<'_, U, E>,
     config: &HelpConfiguration<'_>,
 ) -> Result<String, serenity::Error> {
@@ -348,7 +352,7 @@ async fn generate_all_commands<U, E>(
 }
 
 /// Code for printing an overview of all commands (e.g. `~help`)
-async fn help_all_commands<U, E>(
+async fn help_all_commands<U: Send + Sync + 'static, E>(
     ctx: crate::Context<'_, U, E>,
     config: HelpConfiguration<'_>,
 ) -> Result<(), serenity::Error> {
@@ -414,7 +418,7 @@ async fn help_all_commands<U, E>(
 /// Type ?help command for more info on a command.
 /// You can edit your message to the bot and the bot will edit its response.
 /// ```
-pub async fn help<U, E>(
+pub async fn help<U: Send + Sync + 'static, E>(
     ctx: crate::Context<'_, U, E>,
     command: Option<&str>,
     config: HelpConfiguration<'_>,

src/builtins/mod.rs

@@ -32,7 +32,7 @@ use crate::{serenity_prelude as serenity, CreateReply};
 /// }
 /// # };
 /// ```
-pub async fn on_error<U, E: std::fmt::Display + std::fmt::Debug>(
+pub async fn on_error<U: Send + Sync + 'static, E: std::fmt::Display + std::fmt::Debug>(
     error: crate::FrameworkError<'_, U, E>,
 ) -> Result<(), serenity::Error> {
     match error {
@@ -199,7 +199,7 @@ pub async fn on_error<U, E: std::fmt::Display + std::fmt::Debug>(
 ///
 /// See `examples/feature_showcase` for an example
 #[allow(clippy::unused_async)] // Required for the return type
-pub async fn autocomplete_command<'a, U, E>(
+pub async fn autocomplete_command<'a, U: Send + Sync + 'static, E>(
     ctx: crate::Context<'a, U, E>,
     partial: &'a str,
 ) -> impl Iterator<Item = String> + 'a {
@@ -224,7 +224,9 @@ pub async fn autocomplete_command<'a, U, E>(
 /// > - **A public server** (7123 members)
 /// > - [3 private servers with 456 members total]
 #[cfg(feature = "cache")]
-pub async fn servers<U, E>(ctx: crate::Context<'_, U, E>) -> Result<(), serenity::Error> {
+pub async fn servers<U: Send + Sync + 'static, E>(
+    ctx: crate::Context<'_, U, E>,
+) -> Result<(), serenity::Error> {
     use std::fmt::Write as _;
 
     let show_private_guilds = ctx.framework().options().owners.contains(&ctx.author().id);