[NFC] Use std::optional over llvm::Optional to implement MaybeAlign

[courbet]

llvm/include/llvm/Support/Alignment.h

132

explicit

llvm/lib/Support/OptimizedStructLayout.cpp

14

Layering I guess ?

[gchatelet]

• Add missing explicit

[gchatelet]

llvm/include/llvm/Support/Alignment.h

132

As discussed offline it is always safe to create a MaybeAlign from an Align.
Thx for noticing that an explicit is missing on the line below though.

llvm/lib/Support/OptimizedStructLayout.cpp

14

Yep...

llvm/include/llvm/Support/Alignment.h

 // - MaybeAlign is an optional type, it may be undefined or set. When it's set
 // you can get the underlying Align type by using the getValue() method.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_ALIGNMENT_H_
 #define LLVM_SUPPORT_ALIGNMENT_H_
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/Support/MathExtras.h"
 #include <cassert>
+#include <optional>
 #ifndef NDEBUG
 #include <string>
 #endif // NDEBUG
 
 namespace llvm {
 
 #define ALIGN_CHECK_ISPOSITIVE(decl)                                           \
   assert(decl > 0 && (#decl " should be defined"))
public:
   Align previous() const {
     assert(ShiftValue != 0 && "Undefined operation");
     Align Out;
     Out.ShiftValue = ShiftValue - 1;
     return Out;
   }
 
   /// Allow constructions of constexpr Align.
-  template <size_t kValue> constexpr static LogValue Constant() {
+  template <size_t kValue> constexpr static Align Constant() {
     return LogValue{static_cast<uint8_t>(CTLog2<kValue>())};
   }
 
   /// Allow constructions of constexpr Align from types.
   /// Compile time equivalent to Align(alignof(T)).
-  template <typename T> constexpr static LogValue Of() {
+  template <typename T> constexpr static Align Of() {
     return Constant<std::alignment_of<T>::value>();
   }
 
   /// Constexpr constructor from LogValue type.
   constexpr Align(LogValue CA) : ShiftValue(CA.Log) {}
 };
 
 /// Treats the value 0 as a 1, so Align is always at least 1.
 inline Align assumeAligned(uint64_t Value) {
   return Value ? Align(Value) : Align();
 }
 
 /// This struct is a compact representation of a valid (power of two) or
 /// undefined (0) alignment.
-struct MaybeAlign : public llvm::Optional<Align> {
+struct MaybeAlign : public std::optional<Align> {
 private:
-  using UP = llvm::Optional<Align>;
+  using UP = std::optional<Align>;
 
 public:
   /// Default is undefined.
   MaybeAlign() = default;
   /// Do not perform checks in case of copy/move construct/assign, because the
   /// checks have been performed when building `Other`.
   MaybeAlign(const MaybeAlign &Other) = default;
   MaybeAlign &operator=(const MaybeAlign &Other) = default;
   MaybeAlign(MaybeAlign &&Other) = default;
   MaybeAlign &operator=(MaybeAlign &&Other) = default;
 
-  /// Use llvm::Optional<Align> constructor.
-  using UP::UP;
-
-  explicit MaybeAlign(uint64_t Value) {
+  constexpr MaybeAlign(std::nullopt_t None) : UP(None) {}
+  constexpr MaybeAlign(Align Value) : UP(Value) {}
+  MaybeAlign(uint64_t Value) {
     assert((Value == 0 || llvm::isPowerOf2_64(Value)) &&
            "Alignment is neither 0 nor a power of 2");
     if (Value)
       emplace(Value);
   }
 
   /// For convenience, returns a valid alignment or 1 if undefined.
   Align valueOrOne() const { return value_or(Align()); }

 bool operator<(MaybeAlign Lhs, Align Rhs) = delete;
 bool operator>(MaybeAlign Lhs, Align Rhs) = delete;
 
 bool operator<=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 bool operator>=(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 bool operator<(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 bool operator>(MaybeAlign Lhs, MaybeAlign Rhs) = delete;
 
+// Allow equality comparisons between Align and MaybeAlign.
+inline bool operator==(MaybeAlign Lhs, Align Rhs) { return Lhs && *Lhs == Rhs; }
+inline bool operator!=(MaybeAlign Lhs, Align Rhs) { return !(Lhs == Rhs); }
+inline bool operator==(Align Lhs, MaybeAlign Rhs) { return Rhs == Lhs; }
+inline bool operator!=(Align Lhs, MaybeAlign Rhs) { return !(Rhs == Lhs); }
+// Allow equality comparisons with MaybeAlign.
+inline bool operator==(MaybeAlign Lhs, MaybeAlign Rhs) {
+  return (Lhs && Rhs && (*Lhs == *Rhs)) || (!Lhs && !Rhs);
+}
+inline bool operator!=(MaybeAlign Lhs, MaybeAlign Rhs) { return !(Lhs == Rhs); }
+// Allow equality comparisons with std::nullopt.
+inline bool operator==(MaybeAlign Lhs, std::nullopt_t) { return !bool(Lhs); }
+inline bool operator!=(MaybeAlign Lhs, std::nullopt_t) { return bool(Lhs); }
+inline bool operator==(std::nullopt_t, MaybeAlign Rhs) { return !bool(Rhs); }
+inline bool operator!=(std::nullopt_t, MaybeAlign Rhs) { return bool(Rhs); }
+
 #ifndef NDEBUG
 // For usage in LLVM_DEBUG macros.
 inline std::string DebugStr(const Align &A) {
   return std::to_string(A.value());
 }
 // For usage in LLVM_DEBUG macros.
 inline std::string DebugStr(const MaybeAlign &MA) {
   if (MA)

llvm/lib/Support/OptimizedStructLayout.cpp

 //===--- OptimizedStructLayout.cpp - Optimal data layout algorithm ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the performOptimizedStructLayout interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/OptimizedStructLayout.h"
+#include "llvm/ADT/Optional.h"
 
 using namespace llvm;
 
 using Field = OptimizedStructLayoutField;
 
 #ifndef NDEBUG
 static void checkValidLayout(ArrayRef<Field> Fields, uint64_t Size,
                              Align MaxAlign) {

llvm/unittests/Support/AlignmentTest.cpp

 // slow.
 std::vector<uint64_t> getValidAlignmentsForDeathTest() {
   return {1, 1ULL << 31, 1ULL << 63};
 }
 
 std::vector<uint64_t> getNonPowerOfTwo() { return {3, 10, 15}; }
 
 TEST(AlignmentDeathTest, CantConvertUnsetMaybe) {
-  EXPECT_DEATH((*MaybeAlign(0)), ".*");
+  EXPECT_DEATH((MaybeAlign(0).value()), ".*");
 }
 
 TEST(AlignmentDeathTest, InvalidCTors) {
   EXPECT_DEATH((Align(0)), "Value must not be 0");
   for (uint64_t Value : getNonPowerOfTwo()) {
     EXPECT_DEATH((Align(Value)), "Alignment is not a power of 2");
     EXPECT_DEATH((MaybeAlign(Value)),
                  "Alignment is neither 0 nor a power of 2");