gccrs: Fix issues around PartialEq Eq Ord Partial Ord

There is still an issue with derive on PartialOrd but this adds good tests
and fixes a bug we had handling the default Rhs = Self generic type param
substitutions on the comparison traits.

gcc/rust/ChangeLog:

	* typecheck/rust-tyty.cc (ParamType::handle_substitions): make this consistent

gcc/testsuite/ChangeLog:

	* rust/compile/bug-with-default-generic.rs: New test.
	* rust/execute/torture/partial-eq-1.rs: New test.
	* rust/execute/torture/partial-eq-2.rs: New test.
	* rust/execute/torture/partial-eq-3.rs: New test.
	* rust/execute/torture/partial-eq-4.rs: New test.
	* rust/execute/torture/partial-ord-1.rs: New test.
	* rust/execute/torture/partial-ord-2.rs: New test.
	* rust/execute/torture/partial-ord-3.rs: New test.
	* rust/execute/torture/partial-ord-4.rs: New test.
	* rust/execute/torture/partial-ord-5.rs: New test.

Signed-off-by: Philip Herron <[email protected]>

Author: philberty

gcc/rust/typecheck/rust-tyty.cc

@@ -3545,12 +3545,12 @@ ParamType::handle_substitions (SubstitutionArgumentMappings &subst_mappings)
   ParamType *p = static_cast<ParamType *> (clone ());
   subst_mappings.on_param_subst (*p, arg);
 
-  // there are two cases one where we substitute directly to a new PARAM and
-  // otherwise
-  if (arg.get_tyty ()->get_kind () == TyTy::TypeKind::PARAM)
+  const BaseType *resolved = arg.get_tyty ();
+  if (resolved->get_kind () == TyTy::TypeKind::PARAM)
     {
-      p->set_ty_ref (arg.get_tyty ()->get_ref ());
-      return p;
+      const ParamType &pp = *static_cast<const ParamType *> (resolved);
+      if (pp.can_resolve ())
+	resolved = pp.resolve ();
     }
 
   // this is the new subst that this needs to pass

gcc/testsuite/rust/compile/bug-with-default-generic.rs

@@ -0,0 +1,15 @@
+#[lang = "sized"]
+pub trait Sized {}
+
+pub trait MyBinaryTrait<Rhs = Self> {
+    fn do_something(&self, rhs: &Rhs);
+}
+
+struct Foo<T> {
+    // { dg-warning "struct is never constructed" "" { target *-*-* } .-1 }
+    value: T,
+}
+
+impl<T> MyBinaryTrait for Foo<T> {
+    fn do_something(&self, _rhs: &Self) {}
+}

gcc/testsuite/rust/execute/torture/partial-eq-1.rs

@@ -0,0 +1,103 @@
+/* { dg-output "a == b\r*\na != c\r*\n" }*/
+/* { dg-options "-w" } */
+
+mod core {
+    mod marker {
+        #[lang = "phantom_data"]
+        #[stable(feature = "rust1", since = "1.0.0")]
+        pub struct PhantomData<T: ?Sized>;
+
+        #[unstable(feature = "structural_match", issue = "31434")]
+        #[lang = "structural_peq"]
+        pub trait StructuralPartialEq {
+            // Empty.
+        }
+
+        #[unstable(feature = "structural_match", issue = "31434")]
+        #[lang = "structural_teq"]
+        pub trait StructuralEq {
+            // Empty.
+        }
+
+        #[lang = "sized"]
+        pub trait Sized {}
+    }
+
+    pub mod cmp {
+        use super::marker::Sized;
+
+        #[lang = "eq"]
+        pub trait PartialEq<Rhs: ?Sized = Self> {
+            fn eq(&self, other: &Rhs) -> bool;
+
+            fn ne(&self, other: &Rhs) -> bool {
+                !self.eq(other)
+            }
+        }
+
+        pub trait Eq: PartialEq<Self> {
+            fn assert_receiver_is_total_eq(&self) {}
+        }
+    }
+}
+
+use core::cmp::{Eq, PartialEq};
+
+// PartialEq for i32 and u32 so we can compare across types
+impl PartialEq<u32> for i32 {
+    fn eq(&self, other: &u32) -> bool {
+        *self >= 0 && (*self as u32) == *other
+    }
+}
+impl PartialEq<i32> for u32 {
+    fn eq(&self, other: &i32) -> bool {
+        *other >= 0 && *self == *other as u32
+    }
+}
+
+// Our generic struct
+struct Foo<T> {
+    value: T,
+}
+
+// Manual impl of PartialEq for different generic params
+impl<T, U> PartialEq<Foo<U>> for Foo<T>
+where
+    T: PartialEq<U>,
+{
+    fn eq(&self, other: &Foo<U>) -> bool {
+        self.value.eq(&other.value)
+    }
+}
+
+impl<T: PartialEq> Eq for Foo<T> {}
+
+extern "C" {
+    fn puts(s: *const i8);
+}
+
+fn print(s: &str) {
+    unsafe {
+        puts(s as *const str as *const i8);
+    }
+}
+
+fn main() -> i32 {
+    let a = Foo { value: 42i32 };
+    let b = Foo { value: 42u32 };
+    let c = Foo { value: 7u32 };
+
+    if a == b {
+        print("a == b");
+    } else {
+        print("a != b");
+    }
+
+    if a == c {
+        print("a == c");
+    } else {
+        print("a != c");
+    }
+
+    0
+}

gcc/testsuite/rust/execute/torture/partial-eq-2.rs

@@ -0,0 +1,60 @@
+/* { dg-output "a == b\r*\na != c\r*\n" }*/
+/* { dg-options "-w" } */
+
+#[lang = "sized"]
+pub trait Sized {}
+
+#[lang = "eq"]
+pub trait PartialEq<Rhs: ?Sized = Self> {
+    fn eq(&self, other: &Rhs) -> bool;
+
+    fn ne(&self, other: &Rhs) -> bool {
+        !self.eq(other)
+    }
+}
+
+impl PartialEq for i32 {
+    fn eq(&self, other: &Self) -> bool {
+        *self == *other
+    }
+}
+
+struct Foo<T> {
+    value: T,
+}
+
+impl<T: PartialEq> PartialEq for Foo<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.value.eq(&other.value)
+    }
+}
+
+extern "C" {
+    fn puts(s: *const i8);
+}
+
+fn print(s: &str) {
+    unsafe {
+        puts(s as *const str as *const i8);
+    }
+}
+
+fn main() -> i32 {
+    let a = Foo { value: 42i32 };
+    let b = Foo { value: 42i32 };
+    let c = Foo { value: 99i32 };
+
+    if a == b {
+        print("a == b");
+    } else {
+        print("a != b");
+    }
+
+    if a == c {
+        print("a == c");
+    } else {
+        print("a != c");
+    }
+
+    0
+}