Auto merge of rust-lang#135536 - joshtriplett:str-impls, r=<try>

Add more impls of PartialEq and PartialOrd for strings

Currently, some combinations of `&String` and `&str` don't support
comparison operators. For instance, this:

```rust
fn main() {
    let s1 = String::from("hello");
    let s2 = "world";
    _ = s1 < s2;
}
```

will fail with:
```
error[E0308]: mismatched types
 --> src/main.rs:4:14
  |
4 |     _ = s1 < s2;
  |         --   ^^- help: try using a conversion method: `.to_string()`
  |         |    |
  |         |    expected `String`, found `&str`
  |         expected because this is `String`
```

Other combinations only work because the compiler implicitly relies on
impls on different reference types, and that makes such combinations
fragile, breaking if any other impls of `PartialOrd` show up.

Add some additional impls to make such cases work, and to improve
robustness when adding other impls in the future. In particular, I'm hoping that adding these makes it possible to add comparisons with other stringy types without creating as many inference issues.

Author: bors

library/alloc/src/string.rs

@@ -42,6 +42,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use core::cmp::Ordering;
 use core::error::Error;
 use core::iter::FusedIterator;
 #[cfg(not(no_global_oom_handling))]
@@ -2530,12 +2531,49 @@ macro_rules! impl_eq {
 
 impl_eq! { String, str }
 impl_eq! { String, &'a str }
+impl_eq! { &String, str }
 #[cfg(not(no_global_oom_handling))]
 impl_eq! { Cow<'a, str>, str }
 #[cfg(not(no_global_oom_handling))]
 impl_eq! { Cow<'a, str>, &'b str }
 #[cfg(not(no_global_oom_handling))]
 impl_eq! { Cow<'a, str>, String }
+#[cfg(not(no_global_oom_handling))]
+impl_eq! { Cow<'a, str>, &String }
+
+macro_rules! impl_ord {
+    ($lhs:ty, $rhs: ty) => {
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
+            #[inline]
+            fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
+                PartialOrd::partial_cmp(&self[..], &other[..])
+            }
+        }
+
+        #[stable(feature = "rust1", since = "1.0.0")]
+        #[allow(unused_lifetimes)]
+        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
+            #[inline]
+            fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
+                PartialOrd::partial_cmp(&self[..], &other[..])
+            }
+        }
+    };
+}
+
+impl_ord! { String, str }
+impl_ord! { String, &'a str }
+impl_ord! { &String, str }
+#[cfg(not(no_global_oom_handling))]
+impl_ord! { Cow<'a, str>, str }
+#[cfg(not(no_global_oom_handling))]
+impl_ord! { Cow<'a, str>, &'b str }
+#[cfg(not(no_global_oom_handling))]
+impl_ord! { Cow<'a, str>, String }
+#[cfg(not(no_global_oom_handling))]
+impl_ord! { Cow<'a, str>, &String }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Default for String {

library/core/src/str/traits.rs

@@ -30,6 +30,22 @@ impl PartialEq for str {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialEq<&str> for str {
+    #[inline]
+    fn eq(&self, other: &&str) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialEq<str> for &str {
+    #[inline]
+    fn eq(&self, other: &str) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Eq for str {}
 
@@ -48,6 +64,22 @@ impl PartialOrd for str {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialOrd<&str> for str {
+    #[inline]
+    fn partial_cmp(&self, other: &&str) -> Option<Ordering> {
+        Some(self.cmp(*other))
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialOrd<str> for &str {
+    #[inline]
+    fn partial_cmp(&self, other: &str) -> Option<Ordering> {
+        Some(self.cmp(&other))
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<I> ops::Index<I> for str
 where

tests/ui/binop/binary-op-suggest-deref.rs

@@ -67,9 +67,7 @@ fn baz() {
     let string_ref = &owned;
     let partial = "foobar";
     _ = string_ref == partial[..3];
-    //~^ERROR can't compare `&String` with `str` [E0277]
     _ = partial[..3] == string_ref;
-    //~^ERROR can't compare `str` with `&String` [E0277]
 }
 
 fn qux() {

tests/ui/binop/binary-op-suggest-deref.stderr

@@ -271,32 +271,8 @@ note: an implementation of `PartialEq<&&{integer}>` might be missing for `Foo`
 LL |     struct Foo;
    |     ^^^^^^^^^^ must implement `PartialEq<&&{integer}>`
 
-error[E0277]: can't compare `&String` with `str`
-  --> $DIR/binary-op-suggest-deref.rs:69:20
-   |
-LL |     _ = string_ref == partial[..3];
-   |                    ^^ no implementation for `&String == str`
-   |
-   = help: the trait `PartialEq<str>` is not implemented for `&String`
-help: consider dereferencing here
-   |
-LL |     _ = *string_ref == partial[..3];
-   |         +
-
-error[E0277]: can't compare `str` with `&String`
-  --> $DIR/binary-op-suggest-deref.rs:71:22
-   |
-LL |     _ = partial[..3] == string_ref;
-   |                      ^^ no implementation for `str == &String`
-   |
-   = help: the trait `PartialEq<&String>` is not implemented for `str`
-help: consider dereferencing here
-   |
-LL |     _ = partial[..3] == *string_ref;
-   |                         +
-
 error[E0277]: no implementation for `i32 & str`
-  --> $DIR/binary-op-suggest-deref.rs:78:17
+  --> $DIR/binary-op-suggest-deref.rs:76:17
    |
 LL |     let _ = FOO & (*"Sized".to_string().into_boxed_str());
    |                 ^ no implementation for `i32 & str`
@@ -309,14 +285,14 @@ LL |     let _ = FOO & (*"Sized".to_string().into_boxed_str());
              `i32` implements `BitAnd`
 
 error[E0277]: the size for values of type `str` cannot be known at compilation time
-  --> $DIR/binary-op-suggest-deref.rs:78:17
+  --> $DIR/binary-op-suggest-deref.rs:76:17
    |
 LL |     let _ = FOO & (*"Sized".to_string().into_boxed_str());
    |                 ^ doesn't have a size known at compile-time
    |
    = help: the trait `Sized` is not implemented for `str`
 
-error: aborting due to 24 previous errors
+error: aborting due to 22 previous errors
 
 Some errors have detailed explanations: E0277, E0308, E0369.
 For more information about an error, try `rustc --explain E0277`.