[analysis] Add a FullLattice concept and Inverted lattice

The FullLattice concept extends the base Lattice with `getTop` and `meet`
operations. The `Inverted` lattice uses these operations to reverse the order of
an arbitrary full lattice, for example to create a lattice of integers ordered
by `>` rather than by `<`.

src/analysis/lattice.h

@@ -58,9 +58,25 @@ concept Lattice = requires(const L& lattice,
   { lattice.join(elem, constElem) } noexcept -> std::same_as<bool>;
 };
 
+// The analysis framework only uses bottom elements and least upper bounds (i.e.
+// joins) directly, so lattices do not necessarily need to implement top
+// elements and greatest lower bounds (i.e. meets) to be useable, even though
+// they are required for mathematical lattices. Implementing top elements and
+// meets does have the benefit of making a lattice generically invertable,
+// though. See lattices/inverted.h.
+template<typename L>
+concept FullLattice =
+  Lattice<L> && requires(const L& lattice,
+                         const typename L::Element& constElem,
+                         typename L::Element& elem) {
+    { lattice.getTop() } noexcept -> std::same_as<typename L::Element>;
+    { lattice.meet(elem, constElem) } noexcept -> std::same_as<bool>;
+  };
+
 #else // __cplusplus >= 202002L
 
 #define Lattice typename
+#define FullLattice typename
 
 #endif // __cplusplus >= 202002L
 

src/analysis/lattices/bool.h

@@ -24,6 +24,7 @@ namespace wasm::analysis {
 struct Bool {
   using Element = bool;
   Element getBottom() const noexcept { return false; }
+  Element getTop() const noexcept { return true; }
   LatticeComparison compare(Element a, Element b) const noexcept {
     return a > b ? GREATER : a == b ? EQUAL : LESS;
   }
@@ -34,6 +35,13 @@ struct Bool {
     }
     return false;
   }
+  bool meet(Element& self, Element other) const noexcept {
+    if (self && !other) {
+      self = other;
+      return true;
+    }
+    return false;
+  }
 };
 
 #if __cplusplus >= 202002L

src/analysis/lattices/int.h

@@ -32,6 +32,7 @@ template<typename T>
 struct Integer {
   using Element = T;
   Element getBottom() const noexcept { return std::numeric_limits<T>::min(); }
+  Element getTop() const noexcept { return std::numeric_limits<T>::max(); }
   LatticeComparison compare(Element a, Element b) const noexcept {
     return a > b ? GREATER : a == b ? EQUAL : LESS;
   }
@@ -42,6 +43,13 @@ struct Integer {
     }
     return false;
   }
+  bool meet(Element& self, Element other) const noexcept {
+    if (self > other) {
+      self = other;
+      return true;
+    }
+    return false;
+  }
 };
 
 using Int32 = Integer<int32_t>;
@@ -50,10 +58,10 @@ using Int64 = Integer<int64_t>;
 using UInt64 = Integer<uint64_t>;
 
 #if __cplusplus >= 202002L
-static_assert(Lattice<Int32>);
-static_assert(Lattice<Int64>);
-static_assert(Lattice<UInt32>);
-static_assert(Lattice<UInt64>);
+static_assert(FullLattice<Int32>);
+static_assert(FullLattice<Int64>);
+static_assert(FullLattice<UInt32>);
+static_assert(FullLattice<UInt64>);
 #endif // __cplusplus >= 202002L
 
 } // namespace wasm::analysis

src/analysis/lattices/inverted.h

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_analysis_lattices_inverted_h
+#define wasm_analysis_lattices_inverted_h
+
+#include <utility>
+
+#include "../lattice.h"
+
+namespace wasm::analysis {
+
+template<FullLattice L> struct Inverted {
+  using Element = typename L::Element;
+
+  L lattice;
+  Inverted(L&& lattice) : lattice(std::move(lattice)) {}
+
+  Element getBottom() const noexcept { return lattice.getTop(); }
+  Element getTop() const noexcept { return lattice.getBottom(); }
+  LatticeComparison compare(Element a, Element b) const noexcept {
+    return reverseComparison(lattice.compare(a, b));
+  }
+  bool join(Element& self, Element other) const noexcept {
+    return lattice.meet(self, other);
+  }
+  bool meet(Element& self, Element other) const noexcept {
+    return lattice.join(self, other);
+  }
+};
+
+} // namespace wasm::analysis
+
+#endif // wasm_analysis_lattices_inverted_h

test/gtest/lattices.cpp

@@ -16,6 +16,7 @@
 
 #include "analysis/lattices/bool.h"
 #include "analysis/lattices/int.h"
+#include "analysis/lattices/inverted.h"
 #include "gtest/gtest.h"
 
 using namespace wasm;
@@ -25,6 +26,11 @@ TEST(BoolLattice, GetBottom) {
   EXPECT_FALSE(lattice.getBottom());
 }
 
+TEST(BoolLattice, GetTop) {
+  analysis::Bool lattice;
+  EXPECT_TRUE(lattice.getTop());
+}
+
 TEST(BoolLattice, Compare) {
   analysis::Bool lattice;
   EXPECT_EQ(lattice.compare(false, false), analysis::EQUAL);
@@ -50,18 +56,49 @@ TEST(BoolLattice, Join) {
   ASSERT_TRUE(elem);
 }
 
+TEST(BoolLattice, Meet) {
+  analysis::Bool lattice;
+  bool elem = true;
+
+  EXPECT_FALSE(lattice.meet(elem, true));
+  ASSERT_TRUE(elem);
+
+  EXPECT_TRUE(lattice.meet(elem, false));
+  ASSERT_FALSE(elem);
+
+  EXPECT_FALSE(lattice.meet(elem, true));
+  ASSERT_FALSE(elem);
+
+  EXPECT_FALSE(lattice.meet(elem, false));
+  ASSERT_FALSE(elem);
+}
+
 TEST(IntLattice, GetBottom) {
   analysis::Int32 int32;
-  EXPECT_EQ(int32.getBottom(), (int32_t)(1ll << 31));
+  EXPECT_EQ(int32.getBottom(), (int32_t)(1ull << 31));
 
   analysis::Int64 int64;
-  EXPECT_EQ(int64.getBottom(), (int64_t)(1ll << 63));
+  EXPECT_EQ(int64.getBottom(), (int64_t)(1ull << 63));
 
   analysis::UInt32 uint32;
   EXPECT_EQ(uint32.getBottom(), (uint32_t)0);
 
   analysis::UInt64 uint64;
-  EXPECT_EQ(uint64.getBottom(), (uint32_t)0);
+  EXPECT_EQ(uint64.getBottom(), (uint64_t)0);
+}
+
+TEST(IntLattice, GetTop) {
+  analysis::Int32 int32;
+  EXPECT_EQ(int32.getTop(), (int32_t)((1ull << 31) - 1));
+
+  analysis::Int64 int64;
+  EXPECT_EQ(int64.getTop(), (int64_t)((1ull << 63) - 1));
+
+  analysis::UInt32 uint32;
+  EXPECT_EQ(uint32.getTop(), (uint32_t)-1ull);
+
+  analysis::UInt64 uint64;
+  EXPECT_EQ(uint64.getTop(), (uint64_t)-1ull);
 }
 
 TEST(IntLattice, Compare) {
@@ -84,3 +121,76 @@ TEST(IntLattice, Join) {
   EXPECT_TRUE(int32.join(elem, 100));
   ASSERT_EQ(elem, 100);
 }
+
+TEST(IntLattice, Meet) {
+  analysis::Int32 int32;
+  int elem = 0;
+
+  EXPECT_FALSE(int32.meet(elem, 10));
+  ASSERT_EQ(elem, 0);
+
+  EXPECT_FALSE(int32.meet(elem, 0));
+  ASSERT_EQ(elem, 0);
+
+  EXPECT_TRUE(int32.meet(elem, -100));
+  ASSERT_EQ(elem, -100);
+}
+
+TEST(InvertedLattice, GetBottom) {
+  analysis::Inverted inverted(analysis::Bool{});
+  EXPECT_TRUE(inverted.getBottom());
+}
+
+TEST(InvertedLattice, GetTop) {
+  analysis::Inverted inverted(analysis::Bool{});
+  EXPECT_FALSE(inverted.getTop());
+}
+
+TEST(InvertedLattice, Compare) {
+  analysis::Inverted inverted(analysis::Bool{});
+  EXPECT_EQ(inverted.compare(false, false), analysis::EQUAL);
+  EXPECT_EQ(inverted.compare(false, true), analysis::GREATER);
+  EXPECT_EQ(inverted.compare(true, false), analysis::LESS);
+  EXPECT_EQ(inverted.compare(true, true), analysis::EQUAL);
+}
+
+TEST(InvertedLattice, Join) {
+  analysis::Inverted inverted(analysis::Bool{});
+  bool elem = true;
+
+  EXPECT_FALSE(inverted.join(elem, true));
+  ASSERT_TRUE(elem);
+
+  EXPECT_TRUE(inverted.join(elem, false));
+  ASSERT_FALSE(elem);
+
+  EXPECT_FALSE(inverted.join(elem, true));
+  ASSERT_FALSE(elem);
+
+  EXPECT_FALSE(inverted.join(elem, false));
+  ASSERT_FALSE(elem);
+}
+
+TEST(InvertedLattice, Meet) {
+  analysis::Inverted inverted(analysis::Bool{});
+  bool elem = false;
+
+  EXPECT_FALSE(inverted.meet(elem, false));
+  ASSERT_FALSE(elem);
+
+  EXPECT_TRUE(inverted.meet(elem, true));
+  ASSERT_TRUE(elem);
+
+  EXPECT_FALSE(inverted.meet(elem, false));
+  ASSERT_TRUE(elem);
+
+  EXPECT_FALSE(inverted.meet(elem, true));
+  ASSERT_TRUE(elem);
+}
+
+TEST(InvertedLattice, DoubleInverted) {
+  analysis::Inverted<analysis::Inverted<analysis::Bool>> identity(
+    analysis::Inverted{analysis::Bool{}});
+  EXPECT_FALSE(identity.getBottom());
+  EXPECT_TRUE(identity.getTop());
+}