Made LatticeDomain an own class, such that free functions don't get confused with std::variant

Author: fabianbs96

include/phasar/PhasarLLVM/Utils/LatticeDomain.h

@@ -11,6 +11,7 @@
 #define PHASAR_PHASARLLVM_UTILS_LATTICEDOMAIN_H
 
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <iostream>
 #include <type_traits>
@@ -23,7 +24,11 @@ namespace psr {
 /// the lattice.
 struct Top {};
 
-static inline std::ostream &operator<<(std::ostream &OS, Top /*unused*/) {
+inline std::ostream &operator<<(std::ostream &OS, Top /*unused*/) {
+  return OS << "Top";
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Top /*unused*/) {
   return OS << "Top";
 }
 
@@ -32,17 +37,66 @@ static inline std::ostream &operator<<(std::ostream &OS, Top /*unused*/) {
 /// of the lattice.
 struct Bottom {};
 
-static inline std::ostream &operator<<(std::ostream &OS, Bottom /*unused*/) {
+inline std::ostream &operator<<(std::ostream &OS, Bottom /*unused*/) {
   return OS << "Bottom";
 }
 
-/// A easy shorthand to construct a complete lattice of L.
-template <typename L> using LatticeDomain = std::variant<L, Top, Bottom>;
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, Bottom /*unused*/) {
+  return OS << "Bottom";
+}
 
+/// A easy shorthand to construct a complete lattice of L.
 template <typename L>
+struct LatticeDomain : public std::variant<Top, L, Bottom> {
+  using std::variant<Top, L, Bottom>::variant;
+
+  [[nodiscard]] inline bool isBottom() const noexcept {
+    return std::holds_alternative<Bottom>(*this);
+  }
+  [[nodiscard]] inline bool isTop() const noexcept {
+    return std::holds_alternative<Top>(*this);
+  }
+  [[nodiscard]] inline L *getValueOrNull() noexcept {
+    return std::get_if<L>(this);
+  }
+  [[nodiscard]] inline const L *getValueOrNull() const noexcept {
+    return std::get_if<L>(this);
+  }
+};
+
+// template <typename L> using LatticeDomain = std::variant<L, Top, Bottom>;
+
+template <typename L,
+          typename = std::void_t<decltype(std::declval<std::ostream &>()
+                                          << std::declval<L>())>>
 inline std::ostream &operator<<(std::ostream &OS, const LatticeDomain<L> &LD) {
-  std::visit([&OS](const auto &LVal) { OS << LVal; }, LD);
-  return OS;
+  if (LD.isBottom()) {
+    return OS << "Bottom";
+  }
+  if (LD.isTop()) {
+    return OS << "Top";
+  }
+
+  const auto *Val = LD.getValueOrNull();
+  assert(Val && "Only alternative remaining is L");
+  return OS << *Val;
+}
+
+template <typename L,
+          typename = std::void_t<decltype(std::declval<llvm::raw_ostream &>()
+                                          << std::declval<L>())>>
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const LatticeDomain<L> &LD) {
+  if (LD.isBottom()) {
+    return OS << "Bottom";
+  }
+  if (LD.isTop()) {
+    return OS << "Top";
+  }
+
+  const auto *Val = LD.getValueOrNull();
+  assert(Val && "Only alternative remaining is L");
+  return OS << *Val;
 }
 
 template <typename L>
@@ -52,10 +106,9 @@ inline bool operator==(const LatticeDomain<L> &Lhs,
     return false;
   }
 
-  if (auto LhsPtr = std::get_if<L>(&Lhs)) {
-    if (auto RhsPtr = std::get_if<L>(&Rhs)) {
-      return *LhsPtr == *RhsPtr;
-    }
+  if (auto LhsPtr = Lhs.getValueOrNull()) {
+    /// No need to check whether Lhs is an L; the indices are already the same
+    return *LhsPtr == *Rhs.getValueOrNull();
   }
 
   return true;
@@ -65,7 +118,7 @@ template <
     typename L, typename LL,
     typename = std::void_t<decltype(std::declval<LL>() == std::declval<L>())>>
 inline bool operator==(const LL &Lhs, const LatticeDomain<L> Rhs) {
-  if (const auto *RVal = std::get_if<L>(&Rhs)) {
+  if (const auto *RVal = Rhs.getValueOrNull()) {
     return Lhs == *RVal;
   }
   return false;
@@ -87,26 +140,28 @@ inline bool operator!=(const LatticeDomain<L> &Lhs,
 template <typename L>
 inline bool operator<(const LatticeDomain<L> &Lhs,
                       const LatticeDomain<L> &Rhs) {
-  // Top < (Lhs::L < Rhs::L) < Bottom
-  if (std::holds_alternative<Top>(Rhs)) {
+  /// Top < (Lhs::L < Rhs::L) < Bottom
+  if (Rhs.isTop()) {
     return false;
   }
-  if (std::holds_alternative<Top>(Lhs)) {
+  if (Lhs.isTop()) {
     return true;
   }
 
-  if (auto LhsPtr = std::get_if<L>(&Lhs)) {
-    if (auto RhsPtr = std::get_if<L>(&Rhs)) {
+  if (auto LhsPtr = Lhs.getValueOrNull()) {
+    if (auto RhsPtr = Rhs.getValueOrNull()) {
       return *LhsPtr < *RhsPtr;
     }
   }
 
-  if (std::holds_alternative<Bottom>(Rhs)) {
-    return !std::holds_alternative<Bottom>(Lhs);
-  }
-  if (std::holds_alternative<Bottom>(Lhs)) {
+  if (Lhs.isBottom()) {
     return false;
   }
+
+  if (Rhs.isBottom()) {
+    return true;
+  }
+
   llvm_unreachable("All comparision cases should be handled above.");
 }