Auto merge of #37326 - SimonSapin:from-cow, r=alexcrichton

bors · web-flow · commit febfe7683b98 · 2016-10-22T19:47:05.000-07:00
Implement `From&lt;Cow&lt;str&gt;&gt; for String` and `From&lt;Cow&lt;[T]&gt;&gt; for Vec&lt;T&gt;`.

Motivation: the `selectors` crate is generic over a string type, in order to support all of `String`,  `string_cache::Atom`, and `gecko_string_cache::Atom`. Multiple trait bounds are used for the various operations done with these strings. One of these operations is creating a string (as efficiently as possible, re-using an existing memory allocation if possible) from `Cow&lt;str&gt;`.

The `std::convert::From` trait seems natural for this, but the relevant implementation was missing before this PR. To work around this I’ve added a `FromCowStr` trait in `selectors`, but with trait coherence that means one of `selectors` or `string_cache` needs to depend on the other to implement this trait. Using a trait from `std` would solve this.

The `Vec&lt;T&gt;` implementation is just added for consistency. I also tried a more general `impl&lt;'a, O, B: ?Sized + ToOwned&lt;Owned=O&gt;&gt; From&lt;Cow&lt;'a, B&gt;&gt; for O`, but (the compiler thinks?) it conflicts with `From&lt;T&gt; for T` the impl (after moving all of `collections::borrow` into `core::borrow` to work around trait coherence).
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
@@ -1860,6 +1860,13 @@ impl<'a> From<&'a str> for String {
     }
 }
 
+#[stable(feature = "string_from_cow_str", since = "1.14.0")]
+impl<'a> From<Cow<'a, str>> for String {
+    fn from(s: Cow<'a, str>) -> String {
+        s.into_owned()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> From<&'a str> for Cow<'a, str> {
     #[inline]
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
@@ -1797,6 +1797,13 @@ impl<'a, T: Clone> From<&'a [T]> for Vec<T> {
     }
 }
 
+#[stable(feature = "vec_from_cow_slice", since = "1.14.0")]
+impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {
+    fn from(s: Cow<'a, [T]>) -> Vec<T> {
+        s.into_owned()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> From<&'a str> for Vec<u8> {
     fn from(s: &'a str) -> Vec<u8> {
diff --git a/src/libcollectionstest/string.rs b/src/libcollectionstest/string.rs
@@ -35,6 +35,12 @@ fn test_from_str() {
     assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
 }
 
+#[test]
+fn test_from_cow_str() {
+    assert_eq!(String::from(Cow::Borrowed("string")), "string");
+    assert_eq!(String::from(Cow::Owned(String::from("string"))), "string");
+}
+
 #[test]
 fn test_unsized_to_string() {
     let s: &str = "abc";
diff --git a/src/libcollectionstest/vec.rs b/src/libcollectionstest/vec.rs
@@ -597,6 +597,14 @@ fn test_cow_from() {
     }
 }
 
+#[test]
+fn test_from_cow() {
+    let borrowed: &[_] = &["borrowed", "(slice)"];
+    let owned = vec!["owned", "(vec)"];
+    assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
+    assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
+}
+
 #[allow(dead_code)]
 fn assert_covariance() {
     fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { d }

Original file line number	Diff line number	Diff line change
`@@ -1860,6 +1860,13 @@ impl<'a> From<&'a str> for String {`
`1860`	`1860`	`}`
`1861`	`1861`	`}`
`1862`	`1862`
	`1863`	`+#[stable(feature = "string_from_cow_str", since = "1.14.0")]`
	`1864`	`+impl<'a> From<Cow<'a, str>> for String {`
	`1865`	`+ fn from(s: Cow<'a, str>) -> String {`
	`1866`	`+ s.into_owned()`
	`1867`	`+ }`
	`1868`	`+}`
	`1869`	`+`
`1863`	`1870`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1864`	`1871`	`impl<'a> From<&'a str> for Cow<'a, str> {`
`1865`	`1872`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -1797,6 +1797,13 @@ impl<'a, T: Clone> From<&'a [T]> for Vec<T> {`
`1797`	`1797`	`}`
`1798`	`1798`	`}`
`1799`	`1799`
	`1800`	`+#[stable(feature = "vec_from_cow_slice", since = "1.14.0")]`
	`1801`	`+impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {`
	`1802`	`+ fn from(s: Cow<'a, [T]>) -> Vec<T> {`
	`1803`	`+ s.into_owned()`
	`1804`	`+ }`
	`1805`	`+}`
	`1806`	`+`
`1800`	`1807`	`#[stable(feature = "rust1", since = "1.0.0")]`
`1801`	`1808`	`impl<'a> From<&'a str> for Vec<u8> {`
`1802`	`1809`	`fn from(s: &'a str) -> Vec<u8> {`
Original file line number	Diff line number	Diff line change
`@@ -597,6 +597,14 @@ fn test_cow_from() {`
`597`	`597`	`}`
`598`	`598`	`}`
`599`	`599`
	`600`	`+#[test]`
	`601`	`+fn test_from_cow() {`
	`602`	`+ let borrowed: &[_] = &["borrowed", "(slice)"];`
	`603`	`+ let owned = vec!["owned", "(vec)"];`
	`604`	`+ assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);`
	`605`	`+ assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);`
	`606`	`+}`
	`607`	`+`
`600`	`608`	`#[allow(dead_code)]`
`601`	`609`	`fn assert_covariance() {`
`602`	`610`	`fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { d }`