1 files changed, 122 insertions, 0 deletions
diff --git a/gcc/rust/expand/rust-derive-ord.h b/gcc/rust/expand/rust-derive-ord.h
new file mode 100644
index 0000000..90ce9c8
--- /dev/null
+++ b/gcc/rust/expand/rust-derive-ord.h
@@ -0,0 +1,122 @@
+// Copyright (C) 2025 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#ifndef RUST_DERIVE_ORD_H
+#define RUST_DERIVE_ORD_H
+
+#include "rust-ast.h"
+#include "rust-derive-cmp-common.h"
+#include "rust-derive.h"
+
+namespace Rust {
+namespace AST {
+
+/**
+ * DeriveOrd is a bit special as the expansion of both `PartialOrd` and `Ord`
+ * is extremely similar. The only difference is that `PartialOrd` concerns
+ * partial-ordering, and thus its main method returns an `Option<Ordering>`,
+ * while `Ord` concerns total-ordering, and its main method returns an
+ * `Ordering`. Otherwise, the expansion logic is the same, so we factor both
+ * derives into one.
+ */
+class DeriveOrd : public DeriveVisitor
+{
+public:
+  enum class Ordering
+  {
+    Total,
+    Partial
+  };
+
+  std::string fn (Ordering ordering)
+  {
+    if (ordering == Ordering::Total)
+      return "cmp";
+    else
+      return "partial_cmp";
+  }
+
+  std::string trait (Ordering ordering)
+  {
+    if (ordering == Ordering::Total)
+      return "Ord";
+    else
+      return "PartialOrd";
+  }
+
+  DeriveOrd (Ordering ordering, location_t loc);
+
+  std::unique_ptr<Item> go (Item &item);
+
+private:
+  std::unique_ptr<Item> expanded;
+
+  Ordering ordering;
+
+  /* Identifier patterns for the non-equal match arms */
+  constexpr static const char *not_equal = "#non_eq";
+  constexpr static const char *self_discr = "#self_discr";
+  constexpr static const char *other_discr = "#other_discr";
+
+  /**
+   * Create the recursive matching structure used when implementing the
+   * comparison function on multiple sub items (fields, tuple indexes...)
+   */
+  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
+   * like `Ordering::Equal` and `non_eq` in the following match expression:
+   *
+   * match cmp(...) {
+   *     Ordering::Equal => match cmp(...) { ... }
+   *     non_eq => non_eq,
+   * }
+   */
+  std::pair<MatchArm, MatchArm> make_cmp_arms ();
+
+  /**
+   * Generate a call to the proper trait function, based on the ordering, in
+   * order to compare two given expressions
+   */
+  std::unique_ptr<Expr> cmp_call (std::unique_ptr<Expr> &&self_expr,
+				  std::unique_ptr<Expr> &&other_expr);
+
+  std::unique_ptr<Item>
+  cmp_impl (std::unique_ptr<BlockExpr> &&fn_block, Identifier type_name,
+	    const std::vector<std::unique_ptr<GenericParam>> &type_generics);
+  std::unique_ptr<AssociatedItem> cmp_fn (std::unique_ptr<BlockExpr> &&block,
+					  Identifier type_name);
+
+  virtual void visit_struct (StructStruct &item) override;
+  virtual void visit_tuple (TupleStruct &item) override;
+  virtual void visit_enum (Enum &item) override;
+  virtual void visit_union (Union &item) override;
+};
+
+} // namespace AST
+} // namespace Rust
+
+#endif // ! RUST_DERIVE_ORD_H