auto merge of #19167 : japaric/rust/rhs-cmp, r=aturon

Comparison traits have gained an `Rhs` input parameter that defaults to `Self`. And now the comparison operators can be overloaded to work between different types. In particular, this PR allows the following operations (and their commutative versions):

- `&str` == `String` == `CowString`
- `&[A]` == `&mut [B]` == `Vec<C>` == `CowVec<D>` == `[E, ..N]` (for `N` up to 32)
- `&mut A` == `&B` (for `Sized` `A` and `B`)

Where `A`, `B`, `C`, `D`, `E` may be different types that implement `PartialEq`. For example, these comparisons are now valid: `string == "foo"`, and `vec_of_strings == ["Hello", "world"]`.

[breaking-change]s

Since the `==` may now work on different types, operations that relied on the old "same type restriction" to drive type inference, will need to be type annotated. These are the most common fallout cases:

- `some_vec == some_iter.collect()`: `collect` needs to be type annotated: `collect::<Vec<_>>()`
- `slice == &[a, b, c]`: RHS doesn't get coerced to an slice, use an array instead `[a, b, c]`
- `lhs == []`: Change expression to `lhs.is_empty()`
- `lhs == some_generic_function()`: Type annotate the RHS as necessary

cc #19148

r? @aturon

Author: bors

src/libcollections/dlist.rs

@@ -945,15 +945,15 @@ mod tests {
         let mut m = list_from(v.as_slice());
         m.rotate_backward(); check_links(&m);
         m.rotate_forward(); check_links(&m);
-        assert_eq!(v.iter().collect::<Vec<&int>>(), m.iter().collect());
+        assert_eq!(v.iter().collect::<Vec<&int>>(), m.iter().collect::<Vec<_>>());
         m.rotate_forward(); check_links(&m);
         m.rotate_forward(); check_links(&m);
         m.pop_front(); check_links(&m);
         m.rotate_forward(); check_links(&m);
         m.rotate_backward(); check_links(&m);
         m.push_front(9); check_links(&m);
         m.rotate_forward(); check_links(&m);
-        assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect());
+        assert_eq!(vec![3i,9,5,1,2], m.into_iter().collect::<Vec<_>>());
     }
 
     #[test]

src/libcollections/enum_set.rs

@@ -397,23 +397,23 @@ mod test {
     fn test_iterator() {
         let mut e1: EnumSet<Foo> = EnumSet::new();
 
-        let elems: Vec<Foo> = e1.iter().collect();
+        let elems: ::vec::Vec<Foo> = e1.iter().collect();
         assert!(elems.is_empty())
 
         e1.insert(A);
-        let elems = e1.iter().collect();
+        let elems: ::vec::Vec<_> = e1.iter().collect();
         assert_eq!(vec![A], elems)
 
         e1.insert(C);
-        let elems = e1.iter().collect();
+        let elems: ::vec::Vec<_> = e1.iter().collect();
         assert_eq!(vec![A,C], elems)
 
         e1.insert(C);
-        let elems = e1.iter().collect();
+        let elems: ::vec::Vec<_> = e1.iter().collect();
         assert_eq!(vec![A,C], elems)
 
         e1.insert(B);
-        let elems = e1.iter().collect();
+        let elems: ::vec::Vec<_> = e1.iter().collect();
         assert_eq!(vec![A,B,C], elems)
     }
 
@@ -431,35 +431,35 @@ mod test {
         e2.insert(C);
 
         let e_union = e1 | e2;
-        let elems = e_union.iter().collect();
+        let elems: ::vec::Vec<_> = e_union.iter().collect();
         assert_eq!(vec![A,B,C], elems)
 
         let e_intersection = e1 & e2;
-        let elems = e_intersection.iter().collect();
+        let elems: ::vec::Vec<_> = e_intersection.iter().collect();
         assert_eq!(vec![C], elems)
 
         // Another way to express intersection
         let e_intersection = e1 - (e1 - e2);
-        let elems = e_intersection.iter().collect();
+        let elems: ::vec::Vec<_> = e_intersection.iter().collect();
         assert_eq!(vec![C], elems)
 
         let e_subtract = e1 - e2;
-        let elems = e_subtract.iter().collect();
+        let elems: ::vec::Vec<_> = e_subtract.iter().collect();
         assert_eq!(vec![A], elems)
 
         // Bitwise XOR of two sets, aka symmetric difference
         let e_symmetric_diff = e1 ^ e2;
-        let elems = e_symmetric_diff.iter().collect();
+        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
 
         // Another way to express symmetric difference
         let e_symmetric_diff = (e1 - e2) | (e2 - e1);
-        let elems = e_symmetric_diff.iter().collect();
+        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
 
         // Yet another way to express symmetric difference
         let e_symmetric_diff = (e1 | e2) - (e1 & e2);
-        let elems = e_symmetric_diff.iter().collect();
+        let elems: ::vec::Vec<_> = e_symmetric_diff.iter().collect();
         assert_eq!(vec![A,B], elems)
     }