<ServerName as TryFrom<_>> tweaks

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rustls-pki-types"
-version = "1.0.0"
+version = "1.0.1"
 edition = "2021"
 rust-version = "1.60"
 license = "MIT OR Apache-2.0"

src/server_name.rs

@@ -23,6 +23,18 @@ use std::error::Error as StdError;
 /// ```
 /// # use rustls_pki_types::ServerName;
 /// ServerName::try_from("example.com").expect("invalid DNS name");
+/// ```
+///
+/// If you have an owned `String`, you can use `TryFrom` directly:
+///
+/// ```
+/// # use rustls_pki_types::ServerName;
+/// let name = "example.com".to_string();
+/// #[cfg(feature = "alloc")]
+/// ServerName::try_from(name).expect("invalid DNS name");
+/// ```
+///
+/// which will yield a `ServerName<'static>` if successful.
 ///
 /// // or, alternatively...
 ///
@@ -74,6 +86,21 @@ impl<'a> fmt::Debug for ServerName<'a> {
     }
 }
 
+#[cfg(feature = "alloc")]
+impl TryFrom<String> for ServerName<'static> {
+    type Error = InvalidDnsNameError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        match DnsName::try_from_string(value) {
+            Ok(dns) => Ok(Self::DnsName(dns)),
+            Err(value) => match IpAddr::try_from(value.as_str()) {
+                Ok(ip) => Ok(Self::IpAddress(ip)),
+                Err(_) => Err(InvalidDnsNameError),
+            },
+        }
+    }
+}
+
 impl<'a> TryFrom<&'a [u8]> for ServerName<'a> {
     type Error = InvalidDnsNameError;
 
@@ -91,13 +118,10 @@ impl<'a> TryFrom<&'a str> for ServerName<'a> {
     fn try_from(s: &'a str) -> Result<Self, Self::Error> {
         match DnsName::try_from(s) {
             Ok(dns) => Ok(Self::DnsName(dns)),
-            #[cfg(feature = "std")]
             Err(InvalidDnsNameError) => match IpAddr::try_from(s) {
                 Ok(ip) => Ok(Self::IpAddress(ip)),
                 Err(_) => Err(InvalidDnsNameError),
             },
-            #[cfg(not(feature = "std"))]
-            Err(InvalidDnsNameError) => Err(InvalidDnsNameError),
         }
     }
 }
@@ -132,15 +156,22 @@ impl<'a> DnsName<'a> {
             Self(DnsNameInner::Owned(s)) => s.clone(),
         }))
     }
+
+    #[cfg(feature = "alloc")]
+    fn try_from_string(s: String) -> Result<Self, String> {
+        match validate(s.as_bytes()) {
+            Ok(_) => Ok(Self(DnsNameInner::Owned(s))),
+            Err(_) => Err(s),
+        }
+    }
 }
 
 #[cfg(feature = "alloc")]
 impl TryFrom<String> for DnsName<'static> {
     type Error = InvalidDnsNameError;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {
-        validate(value.as_bytes())?;
-        Ok(Self(DnsNameInner::Owned(value)))
+        Self::try_from_string(value).map_err(|_| InvalidDnsNameError)
     }
 }