Remove selfbot support

While selfbots have always been "roughly tolerated", lately they have
been tolerated to less of a degree.

The simple answer is to no longer support selfbots in any form. This is
done for a few of reasons: 1) in anticipation of selfbots no longer
being tolerated; 2) there are few reasons why one should make a selfbot
in Rust and not a scripting language; 3) there are alternatives
(i.e. discord-rs) that still support userbots. Selfbots are simply not
a goal of the maintainer of serenity.

Upgrade path:

Don't use selfbots with serenity. Use discord-rs instead.

The following has been removed:

Enums:

- `RelationshipType`

Structs:

- `FriendSourceFlags`
- `ReadState`
- `Relationship`
- `SearchResult`
- `SuggestionReason`
- `Tutorial`
- `UserConnection`
- `UserGuildSettings`
- `UserSettings`

Removed the following fields:

- `CurrentUser::mobile`
- Ready::{
     analytics_token,
     experiments,
     friend_suggestion_count,
     notes,
     read_state,
     relationships,
     tutorial,
     user_guild_settings,
     user_settings,
 }

Removed the following methods:

- `Client::login_user`

Deprecated `Client::login_bot` in favour of `Client::login`.

Removed `client::LoginType`.

The following no longer take a `login_type` parameter:

- `Context::new`
- `Shard::new`

`Shard::sync_guilds` has been removed.

The `client::Error::{InvalidOperationAsBot, InvalidOperationAsUser}`
variants have been removed.

The following event handlers on `Client` have been removed:

- `on_friend_suggestion_create`
- `on_friend_suggestion_delete`
- `on_relationship_add`
- `on_relationship_remove`
- `on_user_guild_settings_update`
- `on_note_update`
- `on_user_settings_update`

The following `client::rest` functions have been removed:

- `ack_message`
- `edit_note`
- `get_user_connections`
- `search_channel_messages`
- `search_guild_messages`

The following `client::rest::ratelimiting::Route` variants have been
removed:

- `ChannelsIdMessagesSearch`
- `GuildsIdMessagesSearch`
- `UsersMeConnections`

The following fields on `ext::cache::Cache` have been removed:

- `guild_settings`
- `relationships`
- `settings`

while the following methods have also been removed:

- `update_with_relationship_add`
- `update_with_relationship_remove`
- `update_with_user_guild_settings_update`
- `update_with_user_note_update`
- `update_with_user_settings_update`

The following methods have been removed across models:

- `ChannelId::{ack, search}`
- `Channel::{ack, search}`
- `Group::{ack, search}`
- `GuildChannel::{ack, search}`
- `GuildId::{search, search_channels}`
- `Guild::{search, search_channels}`
- `Message::ack`
- `PartialGuild::{search, search_channels}`
- `PrivateChannel::{ack, search}`
- `UserId::{delete_note, edit_note}`
- `User::{delete_note, edit_note}`

The following events in `model::events` have been removed:

- `FriendSuggestionCreateEvent`
- `FriendSuggestionDeleteEvent`
- `MessageAckEvent`
- `RelationshipAddEvent`
- `RelationshipRemoveEvent`
- `UserGuildSettingsUpdateEvent`
- `UserNoteUpdateEvent`
- `UserSettingsUpdateEvent`

Consequently, the following variants on `model::event::Event` have been
removed:

- `FriendSuggestionCreate`
- `FriendSuggestionDelete`
- `MessageAdd`
- `RelationshipAdd`
- `RelationshipRemove`
- `UserGuildSettingUpdate`
- `UserNoteUpdate`
- `UserSettingsUpdate`

The `utils::builder::Search` search builder has been removed.

1 files changed, 48 insertions, 197 deletions

diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 33267ff..49dbdb0 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -1,7 +1,6 @@
 use std::sync::{Arc, Mutex, RwLock};
 use std::thread;
 use super::event_store::EventStore;
-use super::login_type::LoginType;
 use super::Context;
 use super::gateway::Shard;
 use typemap::ShareMap;
@@ -61,9 +60,8 @@ macro_rules! update {
 
 fn context(channel_id: Option<ChannelId>,
            conn: &Arc<Mutex<Shard>>,
-           data: &Arc<Mutex<ShareMap>>,
-           login_type: LoginType) -> Context {
-    Context::new(channel_id, conn.clone(), data.clone(), login_type)
+           data: &Arc<Mutex<ShareMap>>) -> Context {
+    Context::new(channel_id, conn.clone(), data.clone())
 }
 
 #[cfg(feature="framework")]
@@ -71,14 +69,12 @@ pub fn dispatch(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 framework: &Arc<Mutex<Framework>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::MessageCreate(event) => {
             let context = context(Some(event.message.channel_id),
                                   conn,
-                                  data,
-                                  login_type);
+                                  data);
             let mut framework = framework.lock().unwrap();
 
             if framework.initialized {
@@ -91,7 +87,7 @@ pub fn dispatch(event: Event,
                 dispatch_message(context, event.message, event_store);
             }
         },
-        other => handle_event(other, conn, data, login_type, event_store),
+        other => handle_event(other, conn, data, event_store),
     }
 }
 
@@ -99,19 +95,15 @@ pub fn dispatch(event: Event,
 pub fn dispatch(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::MessageCreate(event) => {
-            let context = context(Some(event.message.channel_id),
-                                  conn,
-                                  data,
-                                  login_type);
+            let context = context(Some(event.message.channel_id), conn, data);
             dispatch_message(context,
                              event.message,
                              event_store);
         },
-        other => handle_event(other, conn, data, login_type, event_store),
+        other => handle_event(other, conn, data, event_store),
     }
 }
 
@@ -127,14 +119,13 @@ fn dispatch_message(context: Context,
 fn handle_event(event: Event,
                 conn: &Arc<Mutex<Shard>>,
                 data: &Arc<Mutex<ShareMap>>,
-                login_type: LoginType,
                 event_store: &Arc<RwLock<EventStore>>) {
     match event {
         Event::CallCreate(event) => {
             if let Some(handler) = handler!(on_call_create, event_store) {
                 update!(update_with_call_create, event);
 
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.call));
             } else {
@@ -143,7 +134,7 @@ fn handle_event(event: Event,
         },
         Event::CallDelete(event) => {
             if let Some(handler) = handler!(on_call_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let call = update!(update_with_call_delete, event);
@@ -158,7 +149,7 @@ fn handle_event(event: Event,
         },
         Event::CallUpdate(event) => {
             if let Some(handler) = handler!(on_call_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_call_update, event, true);
@@ -183,10 +174,7 @@ fn handle_event(event: Event,
         Event::ChannelCreate(event) => {
             if let Some(handler) = handler!(on_channel_create, event_store) {
                 update!(update_with_channel_create, event);
-                let context = context(Some(event.channel.id()),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel.id()), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel));
             } else {
@@ -196,7 +184,7 @@ fn handle_event(event: Event,
         Event::ChannelDelete(event) => {
             if let Some(handler) = handler!(on_channel_delete, event_store) {
                 update!(update_with_channel_delete, event);
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel));
             } else {
@@ -205,20 +193,14 @@ fn handle_event(event: Event,
         },
         Event::ChannelPinsAck(event) => {
             if let Some(handler) = handler!(on_channel_pins_ack, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::ChannelPinsUpdate(event) => {
             if let Some(handler) = handler!(on_channel_pins_update, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -227,10 +209,7 @@ fn handle_event(event: Event,
             update!(update_with_channel_recipient_add, @event);
 
             if let Some(handler) = handler!(on_channel_recipient_addition, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.user));
             }
@@ -239,20 +218,14 @@ fn handle_event(event: Event,
             update!(update_with_channel_recipient_remove, event);
 
             if let Some(handler) = handler!(on_channel_recipient_removal, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.user));
             }
         },
         Event::ChannelUpdate(event) => {
             if let Some(handler) = handler!(on_channel_update, event_store) {
-                let context = context(Some(event.channel.id()),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel.id()), conn, data);
 
                 feature_cache! {{
                     let before = CACHE.read()
@@ -268,30 +241,16 @@ fn handle_event(event: Event,
                 update!(update_with_channel_update, event);
             }
         },
-        Event::FriendSuggestionCreate(event) => {
-            if let Some(handler) = handler!(on_friend_suggestion_create, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.suggested_user, event.reasons));
-            }
-        },
-        Event::FriendSuggestionDelete(event) => {
-            if let Some(handler) = handler!(on_friend_suggestion_delete, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.suggested_user_id));
-            }
-        },
         Event::GuildBanAdd(event) => {
             if let Some(handler) = handler!(on_guild_ban_addition, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.user));
             }
         },
         Event::GuildBanRemove(event) => {
             if let Some(handler) = handler!(on_guild_ban_removal, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.user));
             }
@@ -300,14 +259,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_create, event);
 
             if let Some(handler) = handler!(on_guild_create, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild));
             }
         },
         Event::GuildDelete(event) => {
             if let Some(handler) = handler!(on_guild_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let full = update!(update_with_guild_delete, event);
@@ -327,14 +286,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_emojis_update, event);
 
             if let Some(handler) = handler!(on_guild_emojis_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.emojis));
             }
         },
         Event::GuildIntegrationsUpdate(event) => {
             if let Some(handler) = handler!(on_guild_integrations_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id));
             }
@@ -343,14 +302,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_member_add, @event);
 
             if let Some(handler) = handler!(on_guild_member_addition, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.member));
             }
         },
         Event::GuildMemberRemove(event) => {
             if let Some(handler) = handler!(on_guild_member_removal, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let member = update!(update_with_guild_member_remove, event);
@@ -368,7 +327,7 @@ fn handle_event(event: Event,
         },
         Event::GuildMemberUpdate(event) => {
             if let Some(handler) = handler!(on_guild_member_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_guild_member_update, event);
@@ -394,7 +353,7 @@ fn handle_event(event: Event,
             update!(update_with_guild_members_chunk, event);
 
             if let Some(handler) = handler!(on_guild_members_chunk, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.members));
             }
@@ -403,14 +362,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_role_create, event);
 
             if let Some(handler) = handler!(on_guild_role_create, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.role));
             }
         },
         Event::GuildRoleDelete(event) => {
             if let Some(handler) = handler!(on_guild_role_delete, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let role = update!(update_with_guild_role_delete, event);
@@ -428,7 +387,7 @@ fn handle_event(event: Event,
         },
         Event::GuildRoleUpdate(event) => {
             if let Some(handler) = handler!(on_guild_role_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_guild_role_update, event);
@@ -446,7 +405,7 @@ fn handle_event(event: Event,
         },
         Event::GuildSync(event) => {
             if let Some(handler) = handler!(on_guild_sync, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -455,14 +414,14 @@ fn handle_event(event: Event,
             update!(update_with_guild_unavailable, event);
 
             if let Some(handler) = handler!(on_guild_unavailable, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id));
             }
         },
         Event::GuildUpdate(event) => {
             if let Some(handler) = handler!(on_guild_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = CACHE.read()
@@ -479,45 +438,26 @@ fn handle_event(event: Event,
             } else {
                 update!(update_with_guild_update, event);
             }
-        }
-        Event::MessageAck(event) => {
-            if let Some(handler) = handler!(on_message_ack, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
-
-                thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
-            }
         },
         // Already handled by the framework check macro
         Event::MessageCreate(_) => {},
         Event::MessageDeleteBulk(event) => {
             if let Some(handler) = handler!(on_message_delete_bulk, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.ids));
             }
         },
         Event::MessageDelete(event) => {
             if let Some(handler) = handler!(on_message_delete, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
             }
         },
         Event::MessageUpdate(event) => {
             if let Some(handler) = handler!(on_message_update, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -526,7 +466,7 @@ fn handle_event(event: Event,
             update!(update_with_presences_replace, event);
 
             if let Some(handler) = handler!(on_presence_replace, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.presences));
             }
@@ -535,37 +475,28 @@ fn handle_event(event: Event,
             update!(update_with_presence_update, @event);
 
             if let Some(handler) = handler!(on_presence_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::ReactionAdd(event) => {
             if let Some(handler) = handler!(on_reaction_add, event_store) {
-                let context = context(Some(event.reaction.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.reaction.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.reaction));
             }
         },
         Event::ReactionRemove(event) => {
             if let Some(handler) = handler!(on_reaction_remove, event_store) {
-                let context = context(Some(event.reaction.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.reaction.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.reaction));
             }
         },
         Event::ReactionRemoveAll(event) => {
             if let Some(handler) = handler!(on_reaction_remove_all, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event.channel_id, event.message_id));
             }
@@ -574,117 +505,37 @@ fn handle_event(event: Event,
             if let Some(handler) = handler!(on_ready, event_store) {
                 update!(update_with_ready, event);
 
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.ready));
             } else {
                 update!(update_with_ready, event);
             }
         },
-        Event::RelationshipAdd(event) => {
-            update!(update_with_relationship_add, event);
-
-            if let Some(handler) = handler!(on_relationship_addition, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.relationship));
-            }
-        },
-        Event::RelationshipRemove(event) => {
-            update!(update_with_relationship_remove, event);
-
-            if let Some(handler) = handler!(on_relationship_removal, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                thread::spawn(move || (handler)(context, event.user_id, event.kind));
-            }
-        },
         Event::Resumed(event) => {
             if let Some(handler) = handler!(on_resume, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::TypingStart(event) => {
             if let Some(handler) = handler!(on_typing_start, event_store) {
-                let context = context(Some(event.channel_id),
-                                      conn,
-                                      data,
-                                      login_type);
+                let context = context(Some(event.channel_id), conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
         },
         Event::Unknown(event) => {
             if let Some(handler) = handler!(on_unknown, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.kind, event.value));
             }
         },
-        Event::UserGuildSettingsUpdate(event) => {
-            if let Some(handler) = handler!(on_user_guild_settings_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_guild_settings_update, event);
-
-                    thread::spawn(move || (handler)(context, before, event.settings));
-                } else {
-                    thread::spawn(move || (handler)(context, event.settings));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    let _ = update!(update_with_user_guild_settings_update, event);
-                }
-            }
-        },
-        Event::UserNoteUpdate(event) => {
-            if let Some(handler) = handler!(on_note_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_note_update, event);
-
-                    thread::spawn(move || (handler)(context, event.user_id, before, event.note));
-                } else {
-                    thread::spawn(move || (handler)(context, event.user_id, event.note));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    let _ = update!(update_with_user_note_update, event);
-                }
-            }
-        },
-        Event::UserSettingsUpdate(event) => {
-            if let Some(handler) = handler!(on_user_settings_update, event_store) {
-                let context = context(None, conn, data, login_type);
-
-                feature_cache! {{
-                    let before = update!(update_with_user_settings_update, event, true);
-                    let after = CACHE.read().unwrap().settings.clone();
-
-                    // Unwrap in the spawned thread so that if they don't
-                    // actually exist, then the current thread won't panic.
-                    //
-                    // Yes, this is probably bad.
-                    thread::spawn(move || (handler)(context, before.unwrap(), after.unwrap()));
-                } else {
-                    thread::spawn(move || (handler)(context, event));
-                }}
-            } else {
-                #[cfg(feature="cache")]
-                {
-                    update!(update_with_user_settings_update, event, false);
-                }
-            }
-        },
         Event::UserUpdate(event) => {
             if let Some(handler) = handler!(on_user_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 feature_cache! {{
                     let before = update!(update_with_user_update, event);
@@ -702,7 +553,7 @@ fn handle_event(event: Event,
         },
         Event::VoiceServerUpdate(event) => {
             if let Some(handler) = handler!(on_voice_server_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event));
             }
@@ -711,14 +562,14 @@ fn handle_event(event: Event,
             update!(update_with_voice_state_update, event);
 
             if let Some(handler) = handler!(on_voice_state_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.voice_state));
             }
         },
         Event::WebhookUpdate(event) => {
             if let Some(handler) = handler!(on_webhook_update, event_store) {
-                let context = context(None, conn, data, login_type);
+                let context = context(None, conn, data);
 
                 thread::spawn(move || (handler)(context, event.guild_id, event.channel_id));
             }