diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index 14e1625d..a7757ec4 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -4,7 +4,6 @@ use proc_macro2::{Group, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
-use std::str::FromStr;
 use syn;
 use syn::parse::{self, Parse, ParseStream};
 use syn::punctuated::Punctuated;
@@ -340,13 +339,7 @@ impl Container {
                                 rename_all_ser_rule.set(&m.path, rename_rule);
                                 rename_all_de_rule.set(&m.path, rename_rule);
                             }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value(),
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                         }
                     }
                 }
@@ -357,25 +350,13 @@ impl Container {
                         if let Some(ser) = ser {
                             match RenameRule::from_str(&ser.value()) {
                                 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                             }
                         }
                         if let Some(de) = de {
                             match RenameRule::from_str(&de.value()) {
                                 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                             }
                         }
                     }
@@ -931,13 +912,7 @@ impl Variant {
                                 rename_all_ser_rule.set(&m.path, rename_rule);
                                 rename_all_de_rule.set(&m.path, rename_rule);
                             }
-                            Err(()) => cx.error_spanned_by(
-                                s,
-                                format!(
-                                    "unknown rename rule for #[serde(rename_all = {:?})]",
-                                    s.value()
-                                ),
-                            ),
+                            Err(err) => cx.error_spanned_by(s, err),
                         }
                     }
                 }
@@ -948,25 +923,13 @@ impl Variant {
                         if let Some(ser) = ser {
                             match RenameRule::from_str(&ser.value()) {
                                 Ok(rename_rule) => rename_all_ser_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    ser,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        ser.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(ser, err),
                             }
                         }
                         if let Some(de) = de {
                             match RenameRule::from_str(&de.value()) {
                                 Ok(rename_rule) => rename_all_de_rule.set(&m.path, rename_rule),
-                                Err(()) => cx.error_spanned_by(
-                                    de,
-                                    format!(
-                                        "unknown rename rule for #[serde(rename_all = {:?})]",
-                                        de.value(),
-                                    ),
-                                ),
+                                Err(err) => cx.error_spanned_by(de, err),
                             }
                         }
                     }
diff --git a/serde_derive/src/internals/case.rs b/serde_derive/src/internals/case.rs
index 3fcbb32d..9ed8cd47 100644
--- a/serde_derive/src/internals/case.rs
+++ b/serde_derive/src/internals/case.rs
@@ -5,7 +5,7 @@
 #[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;
 
-use std::str::FromStr;
+use std::fmt::{self, Display};
 
 use self::RenameRule::*;
 
@@ -36,6 +36,20 @@ pub enum RenameRule {
 }
 
 impl RenameRule {
+    pub fn from_str(rename_all_str: &str) -> Result<Self, ParseError> {
+        match rename_all_str {
+            "lowercase" => Ok(LowerCase),
+            "UPPERCASE" => Ok(UPPERCASE),
+            "PascalCase" => Ok(PascalCase),
+            "camelCase" => Ok(CamelCase),
+            "snake_case" => Ok(SnakeCase),
+            "SCREAMING_SNAKE_CASE" => Ok(ScreamingSnakeCase),
+            "kebab-case" => Ok(KebabCase),
+            "SCREAMING-KEBAB-CASE" => Ok(ScreamingKebabCase),
+            unknown => Err(ParseError { unknown }),
+        }
+    }
+
     /// Apply a renaming rule to an enum variant, returning the version expected in the source.
     pub fn apply_to_variant(&self, variant: &str) -> String {
         match *self {
@@ -92,21 +106,17 @@ impl RenameRule {
     }
 }
 
-impl FromStr for RenameRule {
-    type Err = ();
+pub struct ParseError<'a> {
+    unknown: &'a str,
+}
 
-    fn from_str(rename_all_str: &str) -> Result<Self, Self::Err> {
-        match rename_all_str {
-            "lowercase" => Ok(LowerCase),
-            "UPPERCASE" => Ok(UPPERCASE),
-            "PascalCase" => Ok(PascalCase),
-            "camelCase" => Ok(CamelCase),
-            "snake_case" => Ok(SnakeCase),
-            "SCREAMING_SNAKE_CASE" => Ok(ScreamingSnakeCase),
-            "kebab-case" => Ok(KebabCase),
-            "SCREAMING-KEBAB-CASE" => Ok(ScreamingKebabCase),
-            _ => Err(()),
-        }
+impl<'a> Display for ParseError<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "unknown rename rule for #[serde(rename_all = {:?})]",
+            self.unknown,
+        )
     }
 }