[llvm/unittests] Use std::nullopt instead of None (NFC)

This patch mechanically replaces None with std::nullopt where the
compiler would warn if None were deprecated.  The intent is to reduce
the amount of manual work required in migrating from Optional to
std::optional.

This is part of an effort to migrate from llvm::Optional to
std::optional:

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

1 files changed, 24 insertions, 24 deletions

diff --git a/llvm/unittests/Support/CheckedArithmeticTest.cpp b/llvm/unittests/Support/CheckedArithmeticTest.cpp
index 18eee4c..eae54eb 100644
--- a/llvm/unittests/Support/CheckedArithmeticTest.cpp
+++ b/llvm/unittests/Support/CheckedArithmeticTest.cpp
@@ -8,75 +8,75 @@ namespace {
 TEST(CheckedArithmetic, CheckedAdd) {
   const int64_t Max = std::numeric_limits<int64_t>::max();
   const int64_t Min = std::numeric_limits<int64_t>::min();
-  EXPECT_EQ(checkedAdd<int64_t>(Max, Max), None);
-  EXPECT_EQ(checkedAdd<int64_t>(Min, -1), None);
-  EXPECT_EQ(checkedAdd<int64_t>(Max, 1), None);
+  EXPECT_EQ(checkedAdd<int64_t>(Max, Max), std::nullopt);
+  EXPECT_EQ(checkedAdd<int64_t>(Min, -1), std::nullopt);
+  EXPECT_EQ(checkedAdd<int64_t>(Max, 1), std::nullopt);
   EXPECT_EQ(checkedAdd<int64_t>(10, 1), Optional<int64_t>(11));
 }
 
 TEST(CheckedArithmetic, CheckedAddSmall) {
   const int16_t Max = std::numeric_limits<int16_t>::max();
   const int16_t Min = std::numeric_limits<int16_t>::min();
-  EXPECT_EQ(checkedAdd<int16_t>(Max, Max), None);
-  EXPECT_EQ(checkedAdd<int16_t>(Min, -1), None);
-  EXPECT_EQ(checkedAdd<int16_t>(Max, 1), None);
+  EXPECT_EQ(checkedAdd<int16_t>(Max, Max), std::nullopt);
+  EXPECT_EQ(checkedAdd<int16_t>(Min, -1), std::nullopt);
+  EXPECT_EQ(checkedAdd<int16_t>(Max, 1), std::nullopt);
   EXPECT_EQ(checkedAdd<int16_t>(10, 1), Optional<int64_t>(11));
 }
 
 TEST(CheckedArithmetic, CheckedMul) {
   const int64_t Max = std::numeric_limits<int64_t>::max();
   const int64_t Min = std::numeric_limits<int64_t>::min();
-  EXPECT_EQ(checkedMul<int64_t>(Max, 2), None);
-  EXPECT_EQ(checkedMul<int64_t>(Max, Max), None);
-  EXPECT_EQ(checkedMul<int64_t>(Min, 2), None);
+  EXPECT_EQ(checkedMul<int64_t>(Max, 2), std::nullopt);
+  EXPECT_EQ(checkedMul<int64_t>(Max, Max), std::nullopt);
+  EXPECT_EQ(checkedMul<int64_t>(Min, 2), std::nullopt);
   EXPECT_EQ(checkedMul<int64_t>(10, 2), Optional<int64_t>(20));
 }
 
 TEST(CheckedArithmetic, CheckedMulAdd) {
   const int64_t Max = std::numeric_limits<int64_t>::max();
   const int64_t Min = std::numeric_limits<int64_t>::min();
-  EXPECT_EQ(checkedMulAdd<int64_t>(Max, 1, 2), None);
-  EXPECT_EQ(checkedMulAdd<int64_t>(1, 1, Max), None);
-  EXPECT_EQ(checkedMulAdd<int64_t>(1, -1, Min), None);
+  EXPECT_EQ(checkedMulAdd<int64_t>(Max, 1, 2), std::nullopt);
+  EXPECT_EQ(checkedMulAdd<int64_t>(1, 1, Max), std::nullopt);
+  EXPECT_EQ(checkedMulAdd<int64_t>(1, -1, Min), std::nullopt);
   EXPECT_EQ(checkedMulAdd<int64_t>(10, 2, 3), Optional<int64_t>(23));
 }
 
 TEST(CheckedArithmetic, CheckedMulSmall) {
   const int16_t Max = std::numeric_limits<int16_t>::max();
   const int16_t Min = std::numeric_limits<int16_t>::min();
-  EXPECT_EQ(checkedMul<int16_t>(Max, 2), None);
-  EXPECT_EQ(checkedMul<int16_t>(Max, Max), None);
-  EXPECT_EQ(checkedMul<int16_t>(Min, 2), None);
+  EXPECT_EQ(checkedMul<int16_t>(Max, 2), std::nullopt);
+  EXPECT_EQ(checkedMul<int16_t>(Max, Max), std::nullopt);
+  EXPECT_EQ(checkedMul<int16_t>(Min, 2), std::nullopt);
   EXPECT_EQ(checkedMul<int16_t>(10, 2), Optional<int16_t>(20));
 }
 
 TEST(CheckedArithmetic, CheckedMulAddSmall) {
   const int16_t Max = std::numeric_limits<int16_t>::max();
   const int16_t Min = std::numeric_limits<int16_t>::min();
-  EXPECT_EQ(checkedMulAdd<int16_t>(Max, 1, 2), None);
-  EXPECT_EQ(checkedMulAdd<int16_t>(1, 1, Max), None);
-  EXPECT_EQ(checkedMulAdd<int16_t>(1, -1, Min), None);
+  EXPECT_EQ(checkedMulAdd<int16_t>(Max, 1, 2), std::nullopt);
+  EXPECT_EQ(checkedMulAdd<int16_t>(1, 1, Max), std::nullopt);
+  EXPECT_EQ(checkedMulAdd<int16_t>(1, -1, Min), std::nullopt);
   EXPECT_EQ(checkedMulAdd<int16_t>(10, 2, 3), Optional<int16_t>(23));
 }
 
 TEST(CheckedArithmetic, CheckedAddUnsigned) {
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
-  EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, Max), None);
-  EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, 1), None);
+  EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, Max), std::nullopt);
+  EXPECT_EQ(checkedAddUnsigned<uint64_t>(Max, 1), std::nullopt);
   EXPECT_EQ(checkedAddUnsigned<uint64_t>(10, 1), Optional<uint64_t>(11));
 }
 
 TEST(CheckedArithmetic, CheckedMulUnsigned) {
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
-  EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, 2), llvm::None);
-  EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, Max), llvm::None);
+  EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, 2), std::nullopt);
+  EXPECT_EQ(checkedMulUnsigned<uint64_t>(Max, Max), std::nullopt);
   EXPECT_EQ(checkedMulUnsigned<uint64_t>(10, 2), Optional<uint64_t>(20));
 }
 
 TEST(CheckedArithmetic, CheckedMulAddUnsigned) {
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
-  EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(Max, 1, 2), None);
-  EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(1, 1, Max), None);
+  EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(Max, 1, 2), std::nullopt);
+  EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(1, 1, Max), std::nullopt);
   EXPECT_EQ(checkedMulAddUnsigned<uint64_t>(10, 2, 3), Optional<uint64_t>(23));
 }