derive(Ord): Handle unit structs properly

gcc/rust/ChangeLog:

	* expand/rust-derive-ord.cc (DeriveOrd::make_cmp_arms): Use new make_equal function.
	(DeriveOrd::make_equal): New function.
	(DeriveOrd::recursive_match): Handle the unit struct/tuple case.
	* expand/rust-derive-ord.h: Declare make_equal.

Author: CohenArthur

gcc/rust/expand/rust-derive-ord.cc

@@ -109,12 +109,9 @@ DeriveOrd::cmp_fn (std::unique_ptr<BlockExpr> &&block, Identifier type_name)
 			   ptrify (return_type), std::move (block));
 }
 
-std::pair<MatchArm, MatchArm>
-DeriveOrd::make_cmp_arms ()
+std::unique_ptr<Pattern>
+DeriveOrd::make_equal ()
 {
-  // All comparison results other than Ordering::Equal
-  auto non_equal = builder.identifier_pattern (DeriveOrd::not_equal);
-
   std::unique_ptr<Pattern> equal = ptrify (
     builder.path_in_expression ({"core", "cmp", "Ordering", "Equal"}, true));
 
@@ -131,13 +128,37 @@ DeriveOrd::make_cmp_arms ()
 						std::move (pattern_items));
     }
 
+  return equal;
+}
+
+std::pair<MatchArm, MatchArm>
+DeriveOrd::make_cmp_arms ()
+{
+  // All comparison results other than Ordering::Equal
+  auto non_equal = builder.identifier_pattern (DeriveOrd::not_equal);
+  auto equal = make_equal ();
+
   return {builder.match_arm (std::move (equal)),
 	  builder.match_arm (std::move (non_equal))};
 }
 
 std::unique_ptr<Expr>
 DeriveOrd::recursive_match (std::vector<SelfOther> &&members)
 {
+  if (members.empty ())
+    {
+      std::unique_ptr<Expr> value = ptrify (
+	builder.path_in_expression ({"core", "cmp", "Ordering", "Equal"},
+				    true));
+
+      if (ordering == Ordering::Partial)
+	value = builder.call (ptrify (builder.path_in_expression (
+				LangItem::Kind::OPTION_SOME)),
+			      std::move (value));
+
+      return value;
+    }
+
   std::unique_ptr<Expr> final_expr = nullptr;
 
   for (auto it = members.rbegin (); it != members.rend (); it++)

gcc/rust/expand/rust-derive-ord.h

@@ -79,6 +79,12 @@ class DeriveOrd : public DeriveVisitor
    */
   std::unique_ptr<Expr> recursive_match (std::vector<SelfOther> &&members);
 
+  /**
+   * Create a pattern for the `Ordering::Equal` case. In the case of partial
+   * ordering, `Option::Some(Ordering::Equal)`.
+   */
+  std::unique_ptr<Pattern> make_equal ();
+
   /**
    * Make the match arms for one inner match in a comparison function block.
    * This returns the "equal" match arm and the "rest" match arm, so something