Fix compiles of a variety of feature combinations

This fixes compilation errors and warnings when compiling a mixture of
non-default feature targets.

17 files changed, 92 insertions, 74 deletions

diff --git a/src/model/channel/channel_category.rs b/src/model/channel/channel_category.rs
index 554a656..119f1f1 100644
--- a/src/model/channel/channel_category.rs
+++ b/src/model/channel/channel_category.rs
@@ -1,6 +1,10 @@
 use model::*;
+
+#[cfg(all(feature = "builder", feature = "model"))]
 use builder::EditChannel;
+#[cfg(all(feature = "builder", feature = "model"))]
 use http;
+#[cfg(all(feature = "model", feature = "utils"))]
 use utils as serenity_utils;
 
 /// A category of [`GuildChannel`]s.
@@ -77,7 +81,7 @@ impl ChannelCategory {
     /// ```rust,ignore
     /// category.edit(|c| c.name("test").bitrate(86400));
     /// ```
-    #[cfg(feature = "model")]
+    #[cfg(all(feature = "builder", feature = "model"))]
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditChannel) -> EditChannel {
         #[cfg(feature = "cache")]
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index aec6cf0..a8e16ef 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -8,7 +8,7 @@ use std::borrow::Cow;
 use std::fmt::Write as FmtWrite;
 #[cfg(feature = "model")]
 use builder::{CreateMessage, EditChannel, GetMessages};
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
@@ -302,17 +302,23 @@ impl ChannelId {
     pub fn name(&self) -> Option<String> {
         use self::Channel::*;
 
-        // TODO: Replace this second match with `?`.
-        Some(match match self.find() {
-                  Some(c) => c,
-                  None => return None,
-              } {
+        let finding = feature_cache! {{
+            Some(self.find())
+        } else {
+            None
+        }};
+
+        let channel = if let Some(Some(c)) = finding {
+            c
+        } else {
+            return None;
+        };
+
+        Some(match channel {
             Guild(channel) => channel.read().unwrap().name().to_string(),
-            Group(channel) => {
-                match channel.read().unwrap().name() {
-                    Cow::Borrowed(name) => name.to_string(),
-                    Cow::Owned(name) => name,
-                }
+            Group(channel) => match channel.read().unwrap().name() {
+                Cow::Borrowed(name) => name.to_string(),
+                Cow::Owned(name) => name,
             },
             Category(category) => category.read().unwrap().name().to_string(),
             Private(channel) => channel.read().unwrap().name(),
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index ad20fcd..438437c 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -1,15 +1,16 @@
 use chrono::{DateTime, FixedOffset};
 use model::*;
-use internal::RwLockExt;
 
 #[cfg(feature = "model")]
-use std::borrow::Cow;
-#[cfg(feature = "model")]
-use std::fmt::Write as FmtWrite;
-#[cfg(feature = "model")]
 use builder::{CreateMessage, GetMessages};
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
+#[cfg(feature="model")]
+use internal::RwLockExt;
+#[cfg(feature = "model")]
+use std::borrow::Cow;
+#[cfg(feature = "model")]
+use std::fmt::Write as FmtWrite;
 
 /// A group channel - potentially including other [`User`]s - separate from a
 /// [`Guild`].
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 3e33102..e75ba60 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -5,13 +5,13 @@ use model::*;
 use std::fmt::{Display, Formatter, Result as FmtResult};
 #[cfg(feature = "model")]
 use std::mem;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use builder::{CreateInvite, CreateMessage, EditChannel, GetMessages};
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use internal::prelude::*;
 #[cfg(all(feature = "model", feature = "utils"))]
 use utils as serenity_utils;
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 03aea16..1edc9a1 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -2,7 +2,7 @@ use chrono::{DateTime, FixedOffset};
 use serde_json::Value;
 use model::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use std::fmt::Write;
 #[cfg(feature = "model")]
 use std::mem;
@@ -10,7 +10,7 @@ use std::mem;
 use builder::{CreateEmbed, CreateMessage};
 #[cfg(feature = "model")]
 use constants;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use http;
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index c1e22f3..824aea7 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -18,11 +18,11 @@ pub use self::private_channel::*;
 pub use self::reaction::*;
 pub use self::channel_category::*;
 
+use internal::RwLockExt;
 use serde::de::Error as DeError;
 use serde_json;
 use super::utils::deserialize_u64;
 use model::*;
-use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::fmt::{Display, Formatter, Result as FmtResult};
@@ -53,7 +53,6 @@ pub enum Channel {
     Category(Arc<RwLock<ChannelCategory>>),
 }
 
-#[cfg(feature = "model")]
 impl Channel {
     /// React to a [`Message`] with a custom [`Emoji`] or unicode character.
     ///
@@ -67,6 +66,7 @@ impl Channel {
     /// [`Message`]: struct.Message.html
     /// [`Message::react`]: struct.Message.html#method.react
     /// [Add Reactions]: permissions/constant.ADD_REACTIONS.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn create_reaction<M, R>(&self, message_id: M, reaction_type: R) -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
@@ -79,6 +79,7 @@ impl Channel {
     /// closest functionality is leaving it.
     ///
     /// [`Group`]: struct.Group.html
+    #[cfg(feature = "model")]
     pub fn delete(&self) -> Result<()> {
         match *self {
             Channel::Group(ref group) => {
@@ -108,6 +109,7 @@ impl Channel {
     /// [`Message`]: struct.Message.html
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
         self.id().delete_message(message_id)
@@ -120,6 +122,7 @@ impl Channel {
     ///
     /// [`Reaction`]: struct.Reaction.html
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn delete_reaction<M, R>(&self,
                                  message_id: M,
@@ -153,6 +156,7 @@ impl Channel {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [`Message`]: struct.Message.html
     /// [`the limit`]: ../builder/struct.CreateMessage.html#method.content
+    #[cfg(feature = "model")]
     #[inline]
     pub fn edit_message<F, M>(&self, message_id: M, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
@@ -164,14 +168,13 @@ impl Channel {
     /// Refer to [`utils::is_nsfw`] for more details.
     ///
     /// [`utils::is_nsfw`]: ../utils/fn.is_nsfw.html
-    #[cfg(feature = "utils")]
+    #[cfg(all(feature = "model", feature = "utils"))]
     #[inline]
     pub fn is_nsfw(&self) -> bool {
         match *self {
             Channel::Guild(ref channel) => channel.with(|c| c.is_nsfw()),
             Channel::Category(ref category) => category.with(|c| c.is_nsfw()),
-            Channel::Group(_) |
-            Channel::Private(_) => false,
+            Channel::Group(_) | Channel::Private(_) => false,
         }
     }
 
@@ -180,6 +183,7 @@ impl Channel {
     /// Requires the [Read Message History] permission.
     ///
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
         self.id().message(message_id)
@@ -201,6 +205,7 @@ impl Channel {
     /// ```
     ///
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
         where F: FnOnce(GetMessages) -> GetMessages {
@@ -223,6 +228,7 @@ impl Channel {
     /// [`Message`]: struct.Message.html
     /// [`User`]: struct.User.html
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn reaction_users<M, R, U>(&self,
                                    message_id: M,
@@ -264,6 +270,7 @@ impl Channel {
     ///
     /// [`ChannelId`]: struct.ChannelId.html
     /// [`ModelError::MessageTooLong`]: enum.ModelError.html#variant.MessageTooLong
+    #[cfg(feature = "model")]
     #[inline]
     pub fn say(&self, content: &str) -> Result<Message> { self.id().say(content) }
 
@@ -285,6 +292,7 @@ impl Channel {
     /// [`ClientError::MessageTooLong`]: ../client/enum.ClientError.html#variant.MessageTooLong
     /// [Attach Files]: permissions/constant.ATTACH_FILES.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn send_files<'a, F, T>(&self, files: Vec<T>, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
@@ -310,6 +318,7 @@ impl Channel {
     /// [`ModelError::MessageTooLong`]: enum.ModelError.html#variant.MessageTooLong
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn send_message<F>(&self, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage {
@@ -322,6 +331,7 @@ impl Channel {
     ///
     /// [`Message`]: struct.Message.html
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
+    #[cfg(feature = "model")]
     #[inline]
     pub fn unpin<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
         self.id().unpin(message_id)
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index d9abbb2..a51ba09 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -2,12 +2,13 @@ use chrono::{DateTime, FixedOffset};
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use super::deserialize_single_recipient;
 use model::*;
-use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use builder::{CreateMessage, GetMessages};
 #[cfg(feature = "model")]
 use http::AttachmentType;
+#[cfg(feature="model")]
+use internal::RwLockExt;
 
 /// A Direct Message text channel with another user.
 #[derive(Clone, Debug, Deserialize)]
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 121bf43..44e1db6 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -3,7 +3,7 @@ use std::fmt::{Display, Formatter, Result as FmtResult, Write as FmtWrite};
 use internal::prelude::*;
 use model::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use http;
diff --git a/src/model/guild/emoji.rs b/src/model/guild/emoji.rs
index 3893f52..b7cc129 100644
--- a/src/model/guild/emoji.rs
+++ b/src/model/guild/emoji.rs
@@ -1,17 +1,17 @@
 use std::fmt::{Display, Formatter, Result as FmtResult, Write as FmtWrite};
 use super::super::{EmojiId, RoleId};
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use std::mem;
 #[cfg(all(feature = "cache", feature = "model"))]
 use super::super::ModelError;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use internal::prelude::*;
 #[cfg(all(feature = "cache", feature = "model"))]
 use http;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use super::super::GuildId;
 
 /// Represents a custom guild emoji, which can either be created using the API,
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index 350993a..dc060dd 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -1,8 +1,7 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use model::*;
-use model::guild::BanOptions;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use builder::{EditGuild, EditMember, EditRole};
@@ -10,6 +9,8 @@ use builder::{EditGuild, EditMember, EditRole};
 use http;
 #[cfg(feature = "model")]
 use internal::prelude::*;
+#[cfg(feature = "model")]
+use model::guild::BanOptions;
 
 #[cfg(feature = "model")]
 impl GuildId {
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 6873dc7..fcd2ccd 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -5,9 +5,9 @@ use model::*;
 
 #[cfg(feature = "model")]
 use std::borrow::Cow;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use internal::prelude::*;
 #[cfg(all(feature = "cache", feature = "model"))]
 use http;
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index 47f789e..b4b0461 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -22,7 +22,7 @@ use serde_json;
 use super::utils::*;
 use model::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use http;
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 5956113..4b61736 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -2,11 +2,11 @@ use std::cmp::Ordering;
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use model::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(all(feature = "builder", feature = "cache", feature = "model"))]
 use builder::EditRole;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use internal::prelude::*;
 #[cfg(all(feature = "cache", feature = "model"))]
 use http;
diff --git a/src/model/invite.rs b/src/model/invite.rs
index f48ecbc..66196ed 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -1,7 +1,7 @@
 use chrono::{DateTime, FixedOffset};
 use super::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use super::{permissions, utils as model_utils};
 #[cfg(feature = "model")]
 use builder::CreateInvite;
diff --git a/src/model/misc.rs b/src/model/misc.rs
index d54a046..0584018 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -3,15 +3,15 @@ use internal::RwLockExt;
 
 #[cfg(all(feature = "model", feature = "utils"))]
 use std::result::Result as StdResult;
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 use std::error::Error as StdError;
 #[cfg(all(feature = "model", feature = "utils"))]
 use std::str::FromStr;
 #[cfg(all(feature = "model", feature = "utils"))]
 use std::fmt;
-#[cfg(all(feature = "cache", feature = "utils"))]
-use std;
-#[cfg(any(all(feature = "cache", feature = "utils"), all(feature = "model", feature = "utils")))]
+#[cfg(all(feature = "model", feature = "utils"))]
+use std::error::Error;
+#[cfg(all(feature = "model", any(feature = "cache", feature = "utils")))]
 use utils;
 
 /// Allows something - such as a channel or role - to be mentioned in a message.
@@ -60,20 +60,19 @@ impl Mentionable for User {
     fn mention(&self) -> String { format!("<@{}>", self.id.0) }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 #[derive(Debug)]
 pub enum UserParseError {
     InvalidUsername,
-    Rest(Box<std::error::Error>),
+    Rest(Box<Error>),
 }
 
-
 #[cfg(all(feature = "model", feature = "utils"))]
 impl fmt::Display for UserParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.description()) }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 impl StdError for UserParseError {
     fn description(&self) -> &str {
         use self::UserParseError::*;
@@ -85,26 +84,24 @@ impl StdError for UserParseError {
     }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 impl FromStr for User {
     type Err = UserParseError;
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_username(s) {
-            Some(x) => {
-                UserId(x as u64).get().map_err(
-                    |e| UserParseError::Rest(Box::new(e)),
-                )
-            },
+            Some(x) => UserId(x as u64)
+                .get()
+                .map_err(|e| UserParseError::Rest(Box::new(e))),
             _ => Err(UserParseError::InvalidUsername),
         }
     }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 #[derive(Debug)]
 pub enum UserIdParseError {
-    NotPresentInCache,
+    InvalidFormat,
 }
 
 #[cfg(all(feature = "model", feature = "utils"))]
@@ -112,13 +109,13 @@ impl fmt::Display for UserIdParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.description()) }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 impl StdError for UserIdParseError {
     fn description(&self) -> &str {
         use self::UserIdParseError::*;
 
         match *self {
-            NotPresentInCache => "not present in cache",
+            InvalidFormat => "invalid user id format",
         }
     }
 }
@@ -129,24 +126,24 @@ impl FromStr for UserId {
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         utils::parse_username(s)
-            .ok_or_else(|| UserIdParseError::NotPresentInCache)
+            .ok_or_else(|| UserIdParseError::InvalidFormat)
             .map(UserId)
     }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "cache", feature = "model", feature = "utils"))]
 #[derive(Debug)]
 pub enum RoleParseError {
     NotPresentInCache,
     InvalidRole,
 }
 
-#[cfg(all(feature = "model", feature = "utils"))]
+#[cfg(all(feature = "cache", feature = "model", feature = "utils"))]
 impl fmt::Display for RoleParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.description()) }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "cache", feature = "model", feature = "utils"))]
 impl StdError for RoleParseError {
     fn description(&self) -> &str {
         use self::RoleParseError::*;
@@ -158,24 +155,22 @@ impl StdError for RoleParseError {
     }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "cache", feature = "model", feature = "utils"))]
 impl FromStr for Role {
     type Err = RoleParseError;
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_role(s) {
-            Some(x) => {
-                match RoleId(x).find() {
-                    Some(user) => Ok(user),
-                    _ => Err(RoleParseError::NotPresentInCache),
-                }
+            Some(x) => match RoleId(x).find() {
+                Some(user) => Ok(user),
+                _ => Err(RoleParseError::NotPresentInCache),
             },
             _ => Err(RoleParseError::InvalidRole),
         }
     }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 #[derive(Debug)]
 pub enum RoleIdParseError {
     NotPresentInCache,
@@ -186,7 +181,7 @@ impl fmt::Display for RoleIdParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.description()) }
 }
 
-#[cfg(all(feature = "cache", feature = "utils"))]
+#[cfg(all(feature = "model", feature = "utils"))]
 impl StdError for RoleIdParseError {
     fn description(&self) -> &str {
         use self::RoleIdParseError::*;
diff --git a/src/model/user.rs b/src/model/user.rs
index 60efa21..c65a860 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -11,11 +11,11 @@ use chrono::NaiveDateTime;
 use std::fmt::Write;
 #[cfg(feature = "model")]
 use std::mem;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use std::sync::{Arc, RwLock};
 #[cfg(feature = "model")]
 use builder::{CreateMessage, EditProfile};
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
 use http::{self, GuildPagination};
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 89d498a..c90ce46 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -6,9 +6,9 @@ use super::*;
 #[cfg(feature = "cache")]
 use internal::prelude::*;
 
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use super::permissions::Permissions;
-#[cfg(feature = "cache")]
+#[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 
 pub fn deserialize_emojis<'de, D: Deserializer<'de>>(