Add a generic impl of From<Borrow<T>> for Cow<T>

Author: burtonageo

src/liballoc/borrow.rs

@@ -361,6 +361,17 @@ impl<'a, T: ?Sized + ToOwned> AsRef<T> for Cow<'a, T> {
     }
 }
 
+#[unstable(feature = "generic_cow_from", reason = "recently added", issue = "0000")]
+impl<'a, B, T> From<&'a B> for Cow<'a, T>
+where
+    B: ?Sized + Borrow<T>,
+    T: ?Sized + ToOwned,
+{
+    fn from(b: &'a B) -> Self {
+        Cow::Borrowed(b.borrow())
+    }
+}
+
 #[stable(feature = "cow_add", since = "1.14.0")]
 impl<'a> Add<&'a str> for Cow<'a, str> {
     type Output = Cow<'a, str>;

src/liballoc/string.rs

@@ -2128,14 +2128,6 @@ impl<'a> From<Cow<'a, str>> for String {
     }
 }
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for Cow<'a, str> {
-    #[inline]
-    fn from(s: &'a str) -> Cow<'a, str> {
-        Cow::Borrowed(s)
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> From<String> for Cow<'a, str> {
     #[inline]

src/liballoc/tests/borrow.rs

@@ -0,0 +1,44 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::borrow::Cow;
+use std::path::PathBuf;
+use std::ffi::{CStr, CString, OSStr, OSString};
+
+#[test]
+fn test_cow_from() {
+    const MSG: &'static str = "Hello, World";
+    let s = MSG.to_string();
+    assert_eq!(Cow::from(&s), Cow::Borrowed(MSG));
+    assert_eq!(Cow::from(s.as_str()), Cow::Borrowed(MSG));
+    assert_eq!(Cow::from(s), Cow::Owned(MSG.to_string()));
+
+    const VALUES: &'static [u8] = [1u8, 2, 3, 4, 5, 6, 7, 8];
+    let v = VALUES.iter().collect::<Vec<_>>();
+    assert_eq!(Cow::from(&v), Cow::Borrowed(VALUES));
+    assert_eq!(Cow::from(v.as_slice()), Cow::Borrowed(VALUES));
+    assert_eq!(Cow::from(v), Cow::Owned(VALUES.iter().collect::<Vec<_>>()));
+
+    let p = PathBuf::new();
+    assert_eq!(Cow::from(&p), Cow::Borrowed(p.as_path()));
+    assert_eq!(Cow::from(v.as_path()), Cow::Borrowed(p.as_path()));
+
+    let cstring = CString::new(MSG);
+    let cstr = {
+        const MSG_NULL_TERMINATED: &'static str = "Hello, World\0";
+        CStr::from_bytes_with_nul(MSG_NULL_TERMINATED).unwrap()
+    };
+    assert_eq(Cow::from(&cstring), Cow::Borrowed(cstr));
+    assert_eq(Cow::from(cstring.as_c_str()), Cow::Borrowed(cstr));
+
+    let s = OSString::from(MSG.into());
+    assert_eq!(Cow::from(&s), Cow::Borrowed(OSStr::new(msg)));
+    assert_eq!(Cow::from(s.as_os_str()), Cow::Borrowed(OSStr::new(msg)));
+}

src/liballoc/tests/lib.rs

@@ -40,6 +40,7 @@ use std::collections::hash_map::DefaultHasher;
 
 mod binary_heap;
 mod btree;
+mod borrow;
 mod cow_str;
 mod fmt;
 mod heap;

src/liballoc/vec.rs

@@ -2233,13 +2233,6 @@ impl<'a> From<&'a str> for Vec<u8> {
 // Clone-on-write
 ////////////////////////////////////////////////////////////////////////////////
 
-#[stable(feature = "cow_from_vec", since = "1.8.0")]
-impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]> {
-    fn from(s: &'a [T]) -> Cow<'a, [T]> {
-        Cow::Borrowed(s)
-    }
-}
-
 #[stable(feature = "cow_from_vec", since = "1.8.0")]
 impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]> {
     fn from(v: Vec<T>) -> Cow<'a, [T]> {

src/libstd/path.rs

@@ -1445,14 +1445,6 @@ impl Default for PathBuf {
     }
 }
 
-#[stable(feature = "cow_from_path", since = "1.6.0")]
-impl<'a> From<&'a Path> for Cow<'a, Path> {
-    #[inline]
-    fn from(s: &'a Path) -> Cow<'a, Path> {
-        Cow::Borrowed(s)
-    }
-}
-
 #[stable(feature = "cow_from_path", since = "1.6.0")]
 impl<'a> From<PathBuf> for Cow<'a, Path> {
     #[inline]