Don't use Optional::hasValue (NFC)

24 files changed, 307 insertions, 307 deletions

diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp
index f88437f..94032c6 100644
--- a/llvm/unittests/ADT/OptionalTest.cpp
+++ b/llvm/unittests/ADT/OptionalTest.cpp
@@ -29,13 +29,13 @@ void OptionalWorksInConstexpr() {
   constexpr Optional<int> x2{};
   static_assert(!x1.has_value() && !x2.has_value(),
                 "Default construction and hasValue() are contexpr");
-  static_assert(!x1.hasValue() && !x2.hasValue(),
+  static_assert(!x1.has_value() && !x2.has_value(),
                 "Default construction and hasValue() are contexpr");
   constexpr auto y1 = Optional<int>(3);
   constexpr Optional<int> y2{3};
   static_assert(y1.value() == y2.value() && y1.value() == 3,
                 "Construction with value and getValue() are constexpr");
-  static_assert(y1.getValue() == y2.getValue() && y1.getValue() == 3,
+  static_assert(y1.value() == *y2 && *y1 == 3,
                 "Construction with value and getValue() are constexpr");
   static_assert(Optional<int>{3} >= 2 && Optional<int>{1} < Optional<int>{2},
                 "Comparisons work in constexpr");
@@ -252,14 +252,14 @@ TEST(OptionalTest, Emplace) {
   
   A.emplace(1, 2);
   EXPECT_TRUE(A.has_value());
-  EXPECT_TRUE(A.hasValue());
+  EXPECT_TRUE(A.has_value());
   EXPECT_EQ(1, A->x);
   EXPECT_EQ(2, A->y);
   EXPECT_EQ(0u, MultiArgConstructor::Destructions);
 
   A.emplace(5, false);
   EXPECT_TRUE(A.has_value());
-  EXPECT_TRUE(A.hasValue());
+  EXPECT_TRUE(A.has_value());
   EXPECT_EQ(5, A->x);
   EXPECT_EQ(-5, A->y);
   EXPECT_EQ(1u, MultiArgConstructor::Destructions);
@@ -270,12 +270,12 @@ TEST(OptionalTest, InPlaceConstructionMultiArgConstructorTest) {
   {
     Optional<MultiArgConstructor> A{in_place, 1, 2};
     EXPECT_TRUE(A.has_value());
-    EXPECT_TRUE(A.hasValue());
+    EXPECT_TRUE(A.has_value());
     EXPECT_EQ(1, A->x);
     EXPECT_EQ(2, A->y);
     Optional<MultiArgConstructor> B{in_place, 5, false};
     EXPECT_TRUE(B.has_value());
-    EXPECT_TRUE(B.hasValue());
+    EXPECT_TRUE(B.has_value());
     EXPECT_EQ(5, B->x);
     EXPECT_EQ(-5, B->y);
     EXPECT_EQ(0u, MultiArgConstructor::Destructions);
diff --git a/llvm/unittests/ADT/StatisticTest.cpp b/llvm/unittests/ADT/StatisticTest.cpp
index 17d9911..523f510 100644
--- a/llvm/unittests/ADT/StatisticTest.cpp
+++ b/llvm/unittests/ADT/StatisticTest.cpp
@@ -92,8 +92,8 @@ TEST(StatisticTest, API) {
     OptionalStatistic S2;
     extractCounters(Range1, S1, S2);
 
-    EXPECT_EQ(S1.hasValue(), true);
-    EXPECT_EQ(S2.hasValue(), false);
+    EXPECT_EQ(S1.has_value(), true);
+    EXPECT_EQ(S2.has_value(), false);
   }
 
   // Counter2 will be registered when it's first touched.
@@ -108,8 +108,8 @@ TEST(StatisticTest, API) {
     OptionalStatistic S2;
     extractCounters(Range, S1, S2);
 
-    EXPECT_EQ(S1.hasValue(), true);
-    EXPECT_EQ(S2.hasValue(), true);
+    EXPECT_EQ(S1.has_value(), true);
+    EXPECT_EQ(S2.has_value(), true);
 
     EXPECT_EQ(S1->first, "Counter");
     EXPECT_EQ(S1->second, 2u);
@@ -135,8 +135,8 @@ TEST(StatisticTest, API) {
     OptionalStatistic S1;
     OptionalStatistic S2;
     extractCounters(Range, S1, S2);
-    EXPECT_EQ(S1.hasValue(), false);
-    EXPECT_EQ(S2.hasValue(), false);
+    EXPECT_EQ(S1.has_value(), false);
+    EXPECT_EQ(S2.has_value(), false);
   }
 
   // Now check that they successfully re-register and count.
@@ -153,8 +153,8 @@ TEST(StatisticTest, API) {
     OptionalStatistic S2;
     extractCounters(Range, S1, S2);
 
-    EXPECT_EQ(S1.hasValue(), true);
-    EXPECT_EQ(S2.hasValue(), true);
+    EXPECT_EQ(S1.has_value(), true);
+    EXPECT_EQ(S2.has_value(), true);
 
     EXPECT_EQ(S1->first, "Counter");
     EXPECT_EQ(S1->second, 1u);
diff --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
index 5dd3995..91009ab 100644
--- a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
+++ b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp
@@ -75,11 +75,11 @@ TEST_F(BlockFrequencyInfoTest, Basic) {
   EXPECT_EQ(BB0Freq, BB1Freq + BB2Freq);
   EXPECT_EQ(BB0Freq, BB3Freq);
 
-  EXPECT_EQ(BFI.getBlockProfileCount(&BB0).getValue(), UINT64_C(100));
-  EXPECT_EQ(BFI.getBlockProfileCount(BB3).getValue(), UINT64_C(100));
-  EXPECT_EQ(BFI.getBlockProfileCount(BB1).getValue(),
+  EXPECT_EQ(BFI.getBlockProfileCount(&BB0).value(), UINT64_C(100));
+  EXPECT_EQ(BFI.getBlockProfileCount(BB3).value(), UINT64_C(100));
+  EXPECT_EQ(BFI.getBlockProfileCount(BB1).value(),
             (100 * BB1Freq + BB0Freq / 2) / BB0Freq);
-  EXPECT_EQ(BFI.getBlockProfileCount(BB2).getValue(),
+  EXPECT_EQ(BFI.getBlockProfileCount(BB2).value(),
             (100 * BB2Freq + BB0Freq / 2) / BB0Freq);
 
   // Scale the frequencies of BB0, BB1 and BB2 by a factor of two.
diff --git a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
index cfe2c25..f6a0537 100644
--- a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
+++ b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
@@ -2188,9 +2188,9 @@ TEST(IRSimilarityCandidate, CanonicalNumbering) {
   for (std::pair<unsigned, DenseSet<unsigned>> &P : Mapping2) {
     unsigned Source = P.first;
 
-    ASSERT_TRUE(Cand2.getCanonicalNum(Source).hasValue());
+    ASSERT_TRUE(Cand2.getCanonicalNum(Source).has_value());
     unsigned Canon = *Cand2.getCanonicalNum(Source);
-    ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).hasValue());
+    ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).has_value());
     unsigned Dest = *Cand1.fromCanonicalNum(Canon);
 
     DenseSet<unsigned>::iterator It = P.second.find(Dest);
diff --git a/llvm/unittests/Analysis/MemorySSATest.cpp b/llvm/unittests/Analysis/MemorySSATest.cpp
index 298a8bc..4c8942f 100644
--- a/llvm/unittests/Analysis/MemorySSATest.cpp
+++ b/llvm/unittests/Analysis/MemorySSATest.cpp
@@ -1191,14 +1191,13 @@ TEST_F(MemorySSATest, TestStoreMayAlias) {
     EXPECT_EQ(MemDef->isOptimized(), true)
         << "Store " << I << " was not optimized";
     if (I == 1 || I == 3 || I == 4)
-      EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(),
-                AliasResult::MayAlias)
+      EXPECT_EQ(MemDef->getOptimizedAccessType().value(), AliasResult::MayAlias)
           << "Store " << I << " doesn't have the correct alias information";
     else if (I == 0 || I == 2)
       EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
           << "Store " << I << " doesn't have the correct alias information";
     else
-      EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(),
+      EXPECT_EQ(MemDef->getOptimizedAccessType().value(),
                 AliasResult::MustAlias)
           << "Store " << I << " doesn't have the correct alias information";
     // EXPECT_EQ expands such that if we increment I above, it won't get
diff --git a/llvm/unittests/Analysis/VectorFunctionABITest.cpp b/llvm/unittests/Analysis/VectorFunctionABITest.cpp
index 7ac1b03..026732c 100644
--- a/llvm/unittests/Analysis/VectorFunctionABITest.cpp
+++ b/llvm/unittests/Analysis/VectorFunctionABITest.cpp
@@ -75,8 +75,8 @@ protected:
     reset(Name, IRType);
 
     const auto OptInfo = VFABI::tryDemangleForVFABI(MangledName, *(M.get()));
-    if (OptInfo.hasValue()) {
-      Info = OptInfo.getValue();
+    if (OptInfo) {
+      Info = OptInfo.value();
       return true;
     }
 
diff --git a/llvm/unittests/BinaryFormat/DwarfTest.cpp b/llvm/unittests/BinaryFormat/DwarfTest.cpp
index 5e49a5c..ddafbb4 100644
--- a/llvm/unittests/BinaryFormat/DwarfTest.cpp
+++ b/llvm/unittests/BinaryFormat/DwarfTest.cpp
@@ -147,48 +147,48 @@ TEST(DwarfTest, FixedFormSizes) {
   FormParams Params_2_4_32 = {2, 4, DWARF32};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
   AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_TRUE(AddrSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
+  EXPECT_TRUE(AddrSize.has_value());
   EXPECT_EQ(*RefSize, *AddrSize);
 
   // Test 32 bit DWARF version 2 with 8 byte addresses.
   FormParams Params_2_8_32 = {2, 8, DWARF32};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
   AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
-  EXPECT_TRUE(RefSize.hasValue());
-  EXPECT_TRUE(AddrSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
+  EXPECT_TRUE(AddrSize.has_value());
   EXPECT_EQ(*RefSize, *AddrSize);
 
   // DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond.
   FormParams Params_3_4_32 = {3, 4, DWARF32};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 4);
 
   FormParams Params_4_4_32 = {4, 4, DWARF32};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 4);
 
   FormParams Params_5_4_32 = {5, 4, DWARF32};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_4_32);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 4);
 
   // DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond.
   FormParams Params_3_8_64 = {3, 8, DWARF64};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 8);
 
   FormParams Params_4_8_64 = {4, 8, DWARF64};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 8);
 
   FormParams Params_5_8_64 = {5, 8, DWARF64};
   RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_8_64);
-  EXPECT_TRUE(RefSize.hasValue());
+  EXPECT_TRUE(RefSize.has_value());
   EXPECT_EQ(*RefSize, 8);
 }
 
diff --git a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
index 5053d54..33c1f0f 100644
--- a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
@@ -83,157 +83,157 @@ TEST_F(AArch64GISelMITest, FoldBinOp) {
   Optional<APInt> FoldGAddInt =
       ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAddInt.hasValue());
-  EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAddInt.has_value());
+  EXPECT_EQ(25ULL, FoldGAddInt->getLimitedValue());
   Optional<APInt> FoldGAddMix =
       ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAddMix.hasValue());
-  EXPECT_EQ(1073741840ULL, FoldGAddMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAddMix.has_value());
+  EXPECT_EQ(1073741840ULL, FoldGAddMix->getLimitedValue());
 
   // Test G_AND folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGAndInt =
       ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAndInt.hasValue());
-  EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAndInt.has_value());
+  EXPECT_EQ(0ULL, FoldGAndInt->getLimitedValue());
   Optional<APInt> FoldGAndMix =
       ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst2.getReg(0),
                         MIBFCst1.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAndMix.hasValue());
-  EXPECT_EQ(1ULL, FoldGAndMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAndMix.has_value());
+  EXPECT_EQ(1ULL, FoldGAndMix->getLimitedValue());
 
   // Test G_ASHR folding Integer + Mixed cases
   Optional<APInt> FoldGAShrInt =
       ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAShrInt.hasValue());
-  EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAShrInt.has_value());
+  EXPECT_EQ(0ULL, FoldGAShrInt->getLimitedValue());
   Optional<APInt> FoldGAShrMix =
       ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBFCst2.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGAShrMix.hasValue());
-  EXPECT_EQ(2097152ULL, FoldGAShrMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGAShrMix.has_value());
+  EXPECT_EQ(2097152ULL, FoldGAShrMix->getLimitedValue());
 
   // Test G_LSHR folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGLShrInt =
       ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGLShrInt.hasValue());
-  EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGLShrInt.has_value());
+  EXPECT_EQ(0ULL, FoldGLShrInt->getLimitedValue());
   Optional<APInt> FoldGLShrMix =
       ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBFCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGLShrMix.hasValue());
-  EXPECT_EQ(2080768ULL, FoldGLShrMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGLShrMix.has_value());
+  EXPECT_EQ(2080768ULL, FoldGLShrMix->getLimitedValue());
 
   // Test G_MUL folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGMulInt =
       ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGMulInt.hasValue());
-  EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGMulInt.has_value());
+  EXPECT_EQ(144ULL, FoldGMulInt->getLimitedValue());
   Optional<APInt> FoldGMulMix =
       ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGMulMix.hasValue());
-  EXPECT_EQ(0ULL, FoldGMulMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGMulMix.has_value());
+  EXPECT_EQ(0ULL, FoldGMulMix->getLimitedValue());
 
   // Test G_OR folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGOrInt =
       ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGOrInt.hasValue());
-  EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGOrInt.has_value());
+  EXPECT_EQ(25ULL, FoldGOrInt->getLimitedValue());
   Optional<APInt> FoldGOrMix =
       ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGOrMix.hasValue());
-  EXPECT_EQ(1073741840ULL, FoldGOrMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGOrMix.has_value());
+  EXPECT_EQ(1073741840ULL, FoldGOrMix->getLimitedValue());
 
   // Test G_SHL folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGShlInt =
       ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGShlInt.hasValue());
-  EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGShlInt.has_value());
+  EXPECT_EQ(8192ULL, FoldGShlInt->getLimitedValue());
   Optional<APInt> FoldGShlMix =
       ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGShlMix.hasValue());
-  EXPECT_EQ(0ULL, FoldGShlMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGShlMix.has_value());
+  EXPECT_EQ(0ULL, FoldGShlMix->getLimitedValue());
 
   // Test G_SUB folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGSubInt =
       ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSubInt.hasValue());
-  EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSubInt.has_value());
+  EXPECT_EQ(7ULL, FoldGSubInt->getLimitedValue());
   Optional<APInt> FoldGSubMix =
       ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSubMix.hasValue());
-  EXPECT_EQ(3221225488ULL, FoldGSubMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSubMix.has_value());
+  EXPECT_EQ(3221225488ULL, FoldGSubMix->getLimitedValue());
 
   // Test G_XOR folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGXorInt =
       ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGXorInt.hasValue());
-  EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGXorInt.has_value());
+  EXPECT_EQ(25ULL, FoldGXorInt->getLimitedValue());
   Optional<APInt> FoldGXorMix =
       ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGXorMix.hasValue());
-  EXPECT_EQ(1073741840ULL, FoldGXorMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGXorMix.has_value());
+  EXPECT_EQ(1073741840ULL, FoldGXorMix->getLimitedValue());
 
   // Test G_UDIV folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGUdivInt =
       ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGUdivInt.hasValue());
-  EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGUdivInt.has_value());
+  EXPECT_EQ(1ULL, FoldGUdivInt->getLimitedValue());
   Optional<APInt> FoldGUdivMix =
       ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGUdivMix.hasValue());
-  EXPECT_EQ(0ULL, FoldGUdivMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGUdivMix.has_value());
+  EXPECT_EQ(0ULL, FoldGUdivMix->getLimitedValue());
 
   // Test G_SDIV folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGSdivInt =
       ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSdivInt.hasValue());
-  EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSdivInt.has_value());
+  EXPECT_EQ(1ULL, FoldGSdivInt->getLimitedValue());
   Optional<APInt> FoldGSdivMix =
       ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSdivMix.hasValue());
-  EXPECT_EQ(0ULL, FoldGSdivMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSdivMix.has_value());
+  EXPECT_EQ(0ULL, FoldGSdivMix->getLimitedValue());
 
   // Test G_UREM folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGUremInt =
       ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGUremInt.hasValue());
-  EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGUremInt.has_value());
+  EXPECT_EQ(1ULL, FoldGUremInt->getLimitedValue());
   Optional<APInt> FoldGUremMix =
       ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGUremMix.hasValue());
-  EXPECT_EQ(0ULL, FoldGUremMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGUremMix.has_value());
+  EXPECT_EQ(0ULL, FoldGUremMix->getLimitedValue());
 
   // Test G_SREM folding Integer + Mixed Int-Float cases
   Optional<APInt> FoldGSremInt =
       ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
                         MIBCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSremInt.hasValue());
-  EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSremInt.has_value());
+  EXPECT_EQ(7ULL, FoldGSremInt->getLimitedValue());
   Optional<APInt> FoldGSremMix =
       ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
                         MIBFCst2.getReg(0), *MRI);
-  EXPECT_TRUE(FoldGSremMix.hasValue());
-  EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
+  EXPECT_TRUE(FoldGSremMix.has_value());
+  EXPECT_EQ(16ULL, FoldGSremMix->getLimitedValue());
 }
 
 } // namespace
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
index 6a8f23c..dbc54e7 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
@@ -424,31 +424,31 @@ TEST(DWARFDebugFrame, RegisterLocations) {
   // Verify RegisterLocations::getRegisterLocation() works as expected.
   Optional<dwarf::UnwindLocation> OptionalLoc;
   OptionalLoc = Locs.getRegisterLocation(0);
-  EXPECT_FALSE(OptionalLoc.hasValue());
+  EXPECT_FALSE(OptionalLoc.has_value());
 
   OptionalLoc = Locs.getRegisterLocation(12);
-  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_TRUE(OptionalLoc.has_value());
   EXPECT_EQ(*OptionalLoc, Reg12Loc);
 
   OptionalLoc = Locs.getRegisterLocation(13);
-  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_TRUE(OptionalLoc.has_value());
   EXPECT_EQ(*OptionalLoc, Reg13Loc);
 
   OptionalLoc = Locs.getRegisterLocation(14);
-  EXPECT_TRUE(OptionalLoc.hasValue());
+  EXPECT_TRUE(OptionalLoc.has_value());
   EXPECT_EQ(*OptionalLoc, Reg14Loc);
 
   // Verify registers are correctly removed when multiple exist in the list.
   Locs.removeRegisterLocation(13);
-  EXPECT_FALSE(Locs.getRegisterLocation(13).hasValue());
+  EXPECT_FALSE(Locs.getRegisterLocation(13).has_value());
   EXPECT_TRUE(Locs.hasLocations());
   expectDumpResult(Locs, "reg12=[CFA+4], reg14=same");
   Locs.removeRegisterLocation(14);
-  EXPECT_FALSE(Locs.getRegisterLocation(14).hasValue());
+  EXPECT_FALSE(Locs.getRegisterLocation(14).has_value());
   EXPECT_TRUE(Locs.hasLocations());
   expectDumpResult(Locs, "reg12=[CFA+4]");
   Locs.removeRegisterLocation(12);
-  EXPECT_FALSE(Locs.getRegisterLocation(12).hasValue());
+  EXPECT_FALSE(Locs.getRegisterLocation(12).has_value());
   EXPECT_FALSE(Locs.hasLocations());
   expectDumpResult(Locs, "");
 }
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
index 367e89e4..e4c65c0 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
@@ -252,32 +252,32 @@ void TestAllForms() {
   FormValue = DieDG.find(Attr_DW_FORM_block);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
-  EXPECT_TRUE(BlockDataOpt.hasValue());
-  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_TRUE(BlockDataOpt.has_value());
+  ExtractedBlockData = *BlockDataOpt;
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
   FormValue = DieDG.find(Attr_DW_FORM_block1);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
-  EXPECT_TRUE(BlockDataOpt.hasValue());
-  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_TRUE(BlockDataOpt.has_value());
+  ExtractedBlockData = *BlockDataOpt;
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
   FormValue = DieDG.find(Attr_DW_FORM_block2);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
-  EXPECT_TRUE(BlockDataOpt.hasValue());
-  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_TRUE(BlockDataOpt.has_value());
+  ExtractedBlockData = *BlockDataOpt;
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
   FormValue = DieDG.find(Attr_DW_FORM_block4);
   EXPECT_TRUE((bool)FormValue);
   BlockDataOpt = FormValue->getAsBlock();
-  EXPECT_TRUE(BlockDataOpt.hasValue());
-  ExtractedBlockData = BlockDataOpt.getValue();
+  EXPECT_TRUE(BlockDataOpt.has_value());
+  ExtractedBlockData = *BlockDataOpt;
   EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
   EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
 
@@ -286,8 +286,8 @@ void TestAllForms() {
     FormValue = DieDG.find(Attr_DW_FORM_data16);
     EXPECT_TRUE((bool)FormValue);
     BlockDataOpt = FormValue->getAsBlock();
-    EXPECT_TRUE(BlockDataOpt.hasValue());
-    ExtractedBlockData = BlockDataOpt.getValue();
+    EXPECT_TRUE(BlockDataOpt.has_value());
+    ExtractedBlockData = *BlockDataOpt;
     EXPECT_EQ(ExtractedBlockData.size(), 16u);
     EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0);
   }
@@ -989,21 +989,21 @@ template <uint16_t Version, class AddrType> void TestAddresses() {
     EXPECT_FALSE((bool)OptU64);
   } else {
     EXPECT_TRUE((bool)OptU64);
-    EXPECT_EQ(OptU64.getValue(), ActualHighPC);
+    EXPECT_EQ(*OptU64, ActualHighPC);
   }
   // Get the high PC as an unsigned constant. This should succeed if the high PC
   // was encoded as an offset and fail if the high PC was encoded as an address.
   OptU64 = toUnsigned(SubprogramDieLowHighPC.find(DW_AT_high_pc));
   if (SupportsHighPCAsOffset) {
     EXPECT_TRUE((bool)OptU64);
-    EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset);
+    EXPECT_EQ(*OptU64, ActualHighPCOffset);
   } else {
     EXPECT_FALSE((bool)OptU64);
   }
 
   OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC);
   EXPECT_TRUE((bool)OptU64);
-  EXPECT_EQ(OptU64.getValue(), ActualHighPC);
+  EXPECT_EQ(*OptU64, ActualHighPC);
 
   EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex));
   EXPECT_EQ(LowPC, ActualLowPC);
@@ -1638,13 +1638,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   // First test that we don't get valid values back when using an optional with
   // no value.
   Optional<DWARFFormValue> FormValOpt1 = DWARFFormValue();
-  EXPECT_FALSE(toString(FormValOpt1).hasValue());
-  EXPECT_FALSE(toUnsigned(FormValOpt1).hasValue());
-  EXPECT_FALSE(toReference(FormValOpt1).hasValue());
-  EXPECT_FALSE(toSigned(FormValOpt1).hasValue());
-  EXPECT_FALSE(toAddress(FormValOpt1).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt1).hasValue());
-  EXPECT_FALSE(toBlock(FormValOpt1).hasValue());
+  EXPECT_FALSE(toString(FormValOpt1).has_value());
+  EXPECT_FALSE(toUnsigned(FormValOpt1).has_value());
+  EXPECT_FALSE(toReference(FormValOpt1).has_value());
+  EXPECT_FALSE(toSigned(FormValOpt1).has_value());
+  EXPECT_FALSE(toAddress(FormValOpt1).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt1).has_value());
+  EXPECT_FALSE(toBlock(FormValOpt1).has_value());
   EXPECT_EQ(nullptr, toString(FormValOpt1, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt1, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt1, InvalidU64));
@@ -1657,13 +1657,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   Optional<DWARFFormValue> FormValOpt2 =
       DWARFFormValue::createFromUValue(DW_FORM_addr, Address);
 
-  EXPECT_FALSE(toString(FormValOpt2).hasValue());
-  EXPECT_FALSE(toUnsigned(FormValOpt2).hasValue());
-  EXPECT_FALSE(toReference(FormValOpt2).hasValue());
-  EXPECT_FALSE(toSigned(FormValOpt2).hasValue());
-  EXPECT_TRUE(toAddress(FormValOpt2).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt2).hasValue());
-  EXPECT_FALSE(toBlock(FormValOpt2).hasValue());
+  EXPECT_FALSE(toString(FormValOpt2).has_value());
+  EXPECT_FALSE(toUnsigned(FormValOpt2).has_value());
+  EXPECT_FALSE(toReference(FormValOpt2).has_value());
+  EXPECT_FALSE(toSigned(FormValOpt2).has_value());
+  EXPECT_TRUE(toAddress(FormValOpt2).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt2).has_value());
+  EXPECT_FALSE(toBlock(FormValOpt2).has_value());
   EXPECT_EQ(nullptr, toString(FormValOpt2, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt2, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt2, InvalidU64));
@@ -1676,13 +1676,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   Optional<DWARFFormValue> FormValOpt3 =
       DWARFFormValue::createFromUValue(DW_FORM_udata, UData8);
 
-  EXPECT_FALSE(toString(FormValOpt3).hasValue());
-  EXPECT_TRUE(toUnsigned(FormValOpt3).hasValue());
-  EXPECT_FALSE(toReference(FormValOpt3).hasValue());
-  EXPECT_TRUE(toSigned(FormValOpt3).hasValue());
-  EXPECT_FALSE(toAddress(FormValOpt3).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt3).hasValue());
-  EXPECT_FALSE(toBlock(FormValOpt3).hasValue());
+  EXPECT_FALSE(toString(FormValOpt3).has_value());
+  EXPECT_TRUE(toUnsigned(FormValOpt3).has_value());
+  EXPECT_FALSE(toReference(FormValOpt3).has_value());
+  EXPECT_TRUE(toSigned(FormValOpt3).has_value());
+  EXPECT_FALSE(toAddress(FormValOpt3).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt3).has_value());
+  EXPECT_FALSE(toBlock(FormValOpt3).has_value());
   EXPECT_EQ(nullptr, toString(FormValOpt3, nullptr));
   EXPECT_EQ(UData8, toUnsigned(FormValOpt3, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt3, InvalidU64));
@@ -1695,13 +1695,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   Optional<DWARFFormValue> FormValOpt4 =
       DWARFFormValue::createFromUValue(DW_FORM_ref_addr, RefData);
 
-  EXPECT_FALSE(toString(FormValOpt4).hasValue());
-  EXPECT_FALSE(toUnsigned(FormValOpt4).hasValue());
-  EXPECT_TRUE(toReference(FormValOpt4).hasValue());
-  EXPECT_FALSE(toSigned(FormValOpt4).hasValue());
-  EXPECT_FALSE(toAddress(FormValOpt4).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt4).hasValue());
-  EXPECT_FALSE(toBlock(FormValOpt4).hasValue());
+  EXPECT_FALSE(toString(FormValOpt4).has_value());
+  EXPECT_FALSE(toUnsigned(FormValOpt4).has_value());
+  EXPECT_TRUE(toReference(FormValOpt4).has_value());
+  EXPECT_FALSE(toSigned(FormValOpt4).has_value());
+  EXPECT_FALSE(toAddress(FormValOpt4).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt4).has_value());
+  EXPECT_FALSE(toBlock(FormValOpt4).has_value());
   EXPECT_EQ(nullptr, toString(FormValOpt4, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt4, InvalidU64));
   EXPECT_EQ(RefData, toReference(FormValOpt4, InvalidU64));
@@ -1714,13 +1714,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   Optional<DWARFFormValue> FormValOpt5 =
       DWARFFormValue::createFromSValue(DW_FORM_udata, SData8);
 
-  EXPECT_FALSE(toString(FormValOpt5).hasValue());
-  EXPECT_TRUE(toUnsigned(FormValOpt5).hasValue());
-  EXPECT_FALSE(toReference(FormValOpt5).hasValue());
-  EXPECT_TRUE(toSigned(FormValOpt5).hasValue());
-  EXPECT_FALSE(toAddress(FormValOpt5).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt5).hasValue());
-  EXPECT_FALSE(toBlock(FormValOpt5).hasValue());
+  EXPECT_FALSE(toString(FormValOpt5).has_value());
+  EXPECT_TRUE(toUnsigned(FormValOpt5).has_value());
+  EXPECT_FALSE(toReference(FormValOpt5).has_value());
+  EXPECT_TRUE(toSigned(FormValOpt5).has_value());
+  EXPECT_FALSE(toAddress(FormValOpt5).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt5).has_value());
+  EXPECT_FALSE(toBlock(FormValOpt5).has_value());
   EXPECT_EQ(nullptr, toString(FormValOpt5, nullptr));
   EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt5, InvalidU64));
   EXPECT_EQ(InvalidU64, toReference(FormValOpt5, InvalidU64));
@@ -1734,14 +1734,14 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
   Optional<DWARFFormValue> FormValOpt6 =
       DWARFFormValue::createFromBlockValue(DW_FORM_block1, Array);
 
-  EXPECT_FALSE(toString(FormValOpt6).hasValue());
-  EXPECT_FALSE(toUnsigned(FormValOpt6).hasValue());
-  EXPECT_FALSE(toReference(FormValOpt6).hasValue());
-  EXPECT_FALSE(toSigned(FormValOpt6).hasValue());
-  EXPECT_FALSE(toAddress(FormValOpt6).hasValue());
-  EXPECT_FALSE(toSectionOffset(FormValOpt6).hasValue());
+  EXPECT_FALSE(toString(FormValOpt6).has_value());
+  EXPECT_FALSE(toUnsigned(FormValOpt6).has_value());
+  EXPECT_FALSE(toReference(FormValOpt6).has_value());
+  EXPECT_FALSE(toSigned(FormValOpt6).has_value());
+  EXPECT_FALSE(toAddress(FormValOpt6).has_value());
+  EXPECT_FALSE(toSectionOffset(FormValOpt6).has_value());
   auto BlockOpt = toBlock(FormValOpt6);
-  EXPECT_TRUE(BlockOpt.hasValue());
+  EXPECT_TRUE(BlockOpt.has_value());
   EXPECT_EQ(*BlockOpt, Array);
   EXPECT_EQ(nullptr, toString(FormValOpt6, nullptr));
   EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt6, InvalidU64));
@@ -1799,24 +1799,24 @@ TEST(DWARFDebugInfo, TestFindAttrs) {
   auto FuncDie = FuncSpecDie.getSibling();
 
   // Make sure that passing in an empty attribute list behave correctly.
-  EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue());
+  EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).has_value());
 
   // Make sure that passing in a list of attribute that are not contained
   // in the DIE returns nothing.
-  EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue());
+  EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).has_value());
 
   const dwarf::Attribute Attrs[] = {DW_AT_linkage_name,
                                     DW_AT_MIPS_linkage_name};
 
   // Make sure we can't extract the linkage name attributes when using
   // DWARFDie::find() since it won't check the DW_AT_specification DIE.
-  EXPECT_FALSE(FuncDie.find(Attrs).hasValue());
+  EXPECT_FALSE(FuncDie.find(Attrs).has_value());
 
   // Make sure we can extract the name from the specification die when using
   // DWARFDie::findRecursively() since it should recurse through the
   // DW_AT_specification DIE.
   auto NameOpt = FuncDie.findRecursively(Attrs);
-  EXPECT_TRUE(NameOpt.hasValue());
+  EXPECT_TRUE(NameOpt.has_value());
   EXPECT_EQ(DieMangled, toString(NameOpt, ""));
 }
 
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
index 9976777..c81059c 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
@@ -79,17 +79,17 @@ TEST(DWARFFormValue, SignedConstantForms) {
   auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345);
   auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789);
   auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1);
-  EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123);
-  EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345);
-  EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789);
-  EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1);
+  EXPECT_EQ(Sign1.getAsSignedConstant().value(), -123);
+  EXPECT_EQ(Sign2.getAsSignedConstant().value(), -12345);
+  EXPECT_EQ(Sign4.getAsSignedConstant().value(), -123456789);
+  EXPECT_EQ(Sign8.getAsSignedConstant().value(), -1);
 
   // Check that we can handle big positive values, but that we return
   // an error just over the limit.
   auto UMax = createULEBFormValue(LLONG_MAX);
   auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1);
-  EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX);
-  EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false);
+  EXPECT_EQ(UMax.getAsSignedConstant().value(), LLONG_MAX);
+  EXPECT_EQ(TooBig.getAsSignedConstant().has_value(), false);
 
   // Sanity check some other forms.
   auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120);
@@ -100,14 +100,14 @@ TEST(DWARFFormValue, SignedConstantForms) {
   auto LEBMax = createSLEBFormValue(LLONG_MAX);
   auto LEB1 = createSLEBFormValue(-42);
   auto LEB2 = createSLEBFormValue(42);
-  EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120);
-  EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000);
-  EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000);
-  EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL);
-  EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN);
-  EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX);
-  EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42);
-  EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42);
+  EXPECT_EQ(Data1.getAsSignedConstant().value(), 120);
+  EXPECT_EQ(Data2.getAsSignedConstant().value(), 32000);
+  EXPECT_EQ(Data4.getAsSignedConstant().value(), 2000000000);
+  EXPECT_EQ(Data8.getAsSignedConstant().value(), 0x1234567812345678LL);
+  EXPECT_EQ(LEBMin.getAsSignedConstant().value(), LLONG_MIN);
+  EXPECT_EQ(LEBMax.getAsSignedConstant().value(), LLONG_MAX);
+  EXPECT_EQ(LEB1.getAsSignedConstant().value(), -42);
+  EXPECT_EQ(LEB2.getAsSignedConstant().value(), 42);
 
   // Data16 is a little tricky.
   char Cksum[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
diff --git a/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp b/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
index 977231d..bfe66f0 100644
--- a/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
+++ b/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
@@ -1349,8 +1349,8 @@ TEST(GSYMTest, TestDWARFFunctionWithAddresses) {
   auto ExpFI = GR->getFunctionInfo(0x1000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
-  EXPECT_FALSE(ExpFI->Inline.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
+  EXPECT_FALSE(ExpFI->Inline.has_value());
 }
 
 TEST(GSYMTest, TestDWARFFunctionWithAddressAndOffset) {
@@ -1426,8 +1426,8 @@ TEST(GSYMTest, TestDWARFFunctionWithAddressAndOffset) {
   auto ExpFI = GR->getFunctionInfo(0x1000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
-  EXPECT_FALSE(ExpFI->Inline.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
+  EXPECT_FALSE(ExpFI->Inline.has_value());
 }
 
 TEST(GSYMTest, TestDWARFStructMethodNoMangled) {
@@ -1533,8 +1533,8 @@ TEST(GSYMTest, TestDWARFStructMethodNoMangled) {
   auto ExpFI = GR->getFunctionInfo(0x1000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
-  EXPECT_FALSE(ExpFI->Inline.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
+  EXPECT_FALSE(ExpFI->Inline.has_value());
   StringRef MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "Foo::dump");
 }
@@ -1638,8 +1638,8 @@ TEST(GSYMTest, TestDWARFTextRanges) {
   auto ExpFI = GR->getFunctionInfo(0x1000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
-  EXPECT_FALSE(ExpFI->Inline.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
+  EXPECT_FALSE(ExpFI->Inline.has_value());
   StringRef MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "main");
 }
@@ -1667,8 +1667,8 @@ TEST(GSYMTest, TestEmptySymbolEndAddressOfTextRanges) {
   auto ExpFI = GR->getFunctionInfo(0x1500);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1500, 0x2000));
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
-  EXPECT_FALSE(ExpFI->Inline.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
+  EXPECT_FALSE(ExpFI->Inline.has_value());
   StringRef MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "symbol");
 }
@@ -1836,8 +1836,8 @@ TEST(GSYMTest, TestDWARFInlineInfo) {
   auto ExpFI = GR->getFunctionInfo(0x1000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
-  EXPECT_TRUE(ExpFI->OptLineTable.hasValue());
-  EXPECT_TRUE(ExpFI->Inline.hasValue());
+  EXPECT_TRUE(ExpFI->OptLineTable.has_value());
+  EXPECT_TRUE(ExpFI->Inline.has_value());
   StringRef MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "main");
 
@@ -2122,14 +2122,14 @@ TEST(GSYMTest, TestDWARFNoLines) {
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x3000, 0x4000));
   // Make sure we have no line table.
-  EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
+  EXPECT_FALSE(ExpFI->OptLineTable.has_value());
   MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "no_lines_no_decl");
 
   ExpFI = GR->getFunctionInfo(0x4000);
   ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
   ASSERT_EQ(ExpFI->Range, AddressRange(0x4000, 0x5000));
-  EXPECT_TRUE(ExpFI->OptLineTable.hasValue());
+  EXPECT_TRUE(ExpFI->OptLineTable.has_value());
   MethodName = GR->getString(ExpFI->Name);
   EXPECT_EQ(MethodName, "no_lines_with_decl");
   // Make sure we have one line table entry that uses the DW_AT_decl_file/line
diff --git a/llvm/unittests/FileCheck/FileCheckTest.cpp b/llvm/unittests/FileCheck/FileCheckTest.cpp
index f3b5d3d..39230c4 100644
--- a/llvm/unittests/FileCheck/FileCheckTest.cpp
+++ b/llvm/unittests/FileCheck/FileCheckTest.cpp
@@ -766,8 +766,8 @@ TEST_F(FileCheckTest, NumericVariable) {
   ASSERT_TRUE(Value);
   EXPECT_EQ(925, cantFail(Value->getSignedValue()));
   // getStringValue should return the same memory not just the same characters.
-  EXPECT_EQ(StringValue.begin(), FooVar.getStringValue().getValue().begin());
-  EXPECT_EQ(StringValue.end(), FooVar.getStringValue().getValue().end());
+  EXPECT_EQ(StringValue.begin(), FooVar.getStringValue()->begin());
+  EXPECT_EQ(StringValue.end(), FooVar.getStringValue()->end());
   EvalResult = FooVarUse.eval();
   ASSERT_THAT_EXPECTED(EvalResult, Succeeded());
   EXPECT_EQ(925, cantFail(EvalResult->getSignedValue()));
diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp
index 0c73aaa..a755dfa 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -1045,52 +1045,51 @@ TEST_F(DILocationTest, cloneTemporary) {
 }
 
 TEST_F(DILocationTest, discriminatorEncoding) {
-  EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).getValue());
+  EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).value());
 
   // Encode base discriminator as a component: lsb is 0, then the value.
   // The other components are all absent, so we leave all the other bits 0.
-  EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).getValue());
+  EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).value());
 
   // Base discriminator component is empty, so lsb is 1. Next component is not
   // empty, so its lsb is 0, then its value (1). Next component is empty.
   // So the bit pattern is 101.
-  EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).getValue());
+  EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).value());
 
   // First 2 components are empty, so the bit pattern is 11. Then the
   // next component - ending up with 1011.
-  EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).getValue());
+  EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).value());
 
   // The bit pattern for the first 2 components is 11. The next bit is 0,
   // because the last component is not empty. We have 29 bits usable for
   // encoding, but we cap it at 12 bits uniformously for all components. We
   // encode the last component over 14 bits.
-  EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).getValue());
+  EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).value());
 
-  EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).getValue());
+  EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).value());
 
-  EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).getValue());
+  EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).value());
 
-  EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).getValue());
+  EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).value());
 
-  EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).getValue());
+  EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).value());
 
-  EXPECT_EQ(0x3ff3eU,
-            DILocation::encodeDiscriminator(0x1f, 0x1ff, 0).getValue());
+  EXPECT_EQ(0x3ff3eU, DILocation::encodeDiscriminator(0x1f, 0x1ff, 0).value());
 
   EXPECT_EQ(0x1ff87feU,
-            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0).getValue());
+            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0).value());
 
   EXPECT_EQ(0xfff9f3eU,
-            DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff).getValue());
+            DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff).value());
 
   EXPECT_EQ(0xffc3ff3eU,
-            DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff).getValue());
+            DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff).value());
 
   EXPECT_EQ(0xffcf87feU,
-            DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff).getValue());
+            DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff).value());
 
   EXPECT_EQ(0xe1ff87feU,
-            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7).getValue());
+            DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7).value());
 }
 
 TEST_F(DILocationTest, discriminatorEncodingNegativeTests) {
@@ -1113,36 +1112,36 @@ TEST_F(DILocationTest, discriminatorSpecialCases) {
   EXPECT_EQ(0U, L1->getBaseDiscriminator());
   EXPECT_EQ(1U, L1->getDuplicationFactor());
 
-  EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).getValue());
-  EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).getValue());
-  EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).getValue());
+  EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).value());
+  EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).value());
+  EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).value());
 
-  auto L2 = L1->cloneWithBaseDiscriminator(1).getValue();
+  auto L2 = L1->cloneWithBaseDiscriminator(1).value();
   EXPECT_EQ(0U, L1->getBaseDiscriminator());
   EXPECT_EQ(1U, L1->getDuplicationFactor());
 
   EXPECT_EQ(1U, L2->getBaseDiscriminator());
   EXPECT_EQ(1U, L2->getDuplicationFactor());
 
-  auto L3 = L2->cloneByMultiplyingDuplicationFactor(2).getValue();
+  auto L3 = L2->cloneByMultiplyingDuplicationFactor(2).value();
   EXPECT_EQ(1U, L3->getBaseDiscriminator());
   EXPECT_EQ(2U, L3->getDuplicationFactor());
 
-  EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).getValue());
+  EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).value());
 
-  auto L4 = L3->cloneByMultiplyingDuplicationFactor(4).getValue();
+  auto L4 = L3->cloneByMultiplyingDuplicationFactor(4).value();
   EXPECT_EQ(1U, L4->getBaseDiscriminator());
   EXPECT_EQ(8U, L4->getDuplicationFactor());
 
-  auto L5 = L4->cloneWithBaseDiscriminator(2).getValue();
+  auto L5 = L4->cloneWithBaseDiscriminator(2).value();
   EXPECT_EQ(2U, L5->getBaseDiscriminator());
   EXPECT_EQ(8U, L5->getDuplicationFactor());
 
   // Check extreme cases
-  auto L6 = L1->cloneWithBaseDiscriminator(0xfff).getValue();
+  auto L6 = L1->cloneWithBaseDiscriminator(0xfff).value();
   EXPECT_EQ(0xfffU, L6->getBaseDiscriminator());
   EXPECT_EQ(0xfffU, L6->cloneByMultiplyingDuplicationFactor(0xfff)
-                        .getValue()
+                        .value()
                         ->getDuplicationFactor());
 
   // Check we return None for unencodable cases.
@@ -2933,22 +2932,24 @@ TEST_F(DIExpressionTest, createFragmentExpression) {
 #define EXPECT_VALID_FRAGMENT(Offset, Size, ...)                               \
   do {                                                                         \
     uint64_t Elements[] = {__VA_ARGS__};                                       \
-    DIExpression* Expression = DIExpression::get(Context, Elements);           \
-    EXPECT_TRUE(DIExpression::createFragmentExpression(                        \
-      Expression, Offset, Size).hasValue());                                   \
+    DIExpression *Expression = DIExpression::get(Context, Elements);           \
+    EXPECT_TRUE(                                                               \
+        DIExpression::createFragmentExpression(Expression, Offset, Size)       \
+            .has_value());                                                     \
   } while (false)
 #define EXPECT_INVALID_FRAGMENT(Offset, Size, ...)                             \
   do {                                                                         \
     uint64_t Elements[] = {__VA_ARGS__};                                       \
-    DIExpression* Expression = DIExpression::get(Context, Elements);           \
-    EXPECT_FALSE(DIExpression::createFragmentExpression(                       \
-      Expression, Offset, Size).hasValue());                                   \
+    DIExpression *Expression = DIExpression::get(Context, Elements);           \
+    EXPECT_FALSE(                                                              \
+        DIExpression::createFragmentExpression(Expression, Offset, Size)       \
+            .has_value());                                                     \
   } while (false)
 
   // createFragmentExpression adds correct ops.
   Optional<DIExpression*> R = DIExpression::createFragmentExpression(
     DIExpression::get(Context, {}), 0, 32);
-  EXPECT_EQ(R.hasValue(), true);
+  EXPECT_EQ(R.has_value(), true);
   EXPECT_EQ(3u, (*R)->getNumElements());
   EXPECT_EQ(dwarf::DW_OP_LLVM_fragment, (*R)->getElement(0));
   EXPECT_EQ(0u, (*R)->getElement(1));
@@ -3455,20 +3456,20 @@ TEST_F(FunctionAttachmentTest, Verifier) {
 
 TEST_F(FunctionAttachmentTest, RealEntryCount) {
   Function *F = getFunction("foo");
-  EXPECT_FALSE(F->getEntryCount().hasValue());
+  EXPECT_FALSE(F->getEntryCount().has_value());
   F->setEntryCount(12304, Function::PCT_Real);
   auto Count = F->getEntryCount();
-  EXPECT_TRUE(Count.hasValue());
+  EXPECT_TRUE(Count.has_value());
   EXPECT_EQ(12304u, Count->getCount());
   EXPECT_EQ(Function::PCT_Real, Count->getType());
 }
 
 TEST_F(FunctionAttachmentTest, SyntheticEntryCount) {
   Function *F = getFunction("bar");
-  EXPECT_FALSE(F->getEntryCount().hasValue());
+  EXPECT_FALSE(F->getEntryCount().has_value());
   F->setEntryCount(123, Function::PCT_Synthetic);
   auto Count = F->getEntryCount(true /*allow synthetic*/);
-  EXPECT_TRUE(Count.hasValue());
+  EXPECT_TRUE(Count.has_value());
   EXPECT_EQ(123u, Count->getCount());
   EXPECT_EQ(Function::PCT_Synthetic, Count->getType());
 }
diff --git a/llvm/unittests/IR/VPIntrinsicTest.cpp b/llvm/unittests/IR/VPIntrinsicTest.cpp
index 62e16df..34123ef 100644
--- a/llvm/unittests/IR/VPIntrinsicTest.cpp
+++ b/llvm/unittests/IR/VPIntrinsicTest.cpp
@@ -128,25 +128,25 @@ protected:
 TEST_F(VPIntrinsicTest, VPIntrinsicsDefScopes) {
   Optional<Intrinsic::ID> ScopeVPID;
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...)                                 \
-  ASSERT_FALSE(ScopeVPID.hasValue());                                          \
+  ASSERT_FALSE(ScopeVPID.has_value());                                         \
   ScopeVPID = Intrinsic::VPID;
 #define END_REGISTER_VP_INTRINSIC(VPID)                                        \
-  ASSERT_TRUE(ScopeVPID.hasValue());                                           \
-  ASSERT_EQ(ScopeVPID.getValue(), Intrinsic::VPID);                            \
+  ASSERT_TRUE(ScopeVPID.has_value());                                          \
+  ASSERT_EQ(*ScopeVPID, Intrinsic::VPID);                                      \
   ScopeVPID = None;
 
   Optional<ISD::NodeType> ScopeOPC;
 #define BEGIN_REGISTER_VP_SDNODE(SDOPC, ...)                                   \
-  ASSERT_FALSE(ScopeOPC.hasValue());                                           \
+  ASSERT_FALSE(ScopeOPC.has_value());                                          \
   ScopeOPC = ISD::SDOPC;
 #define END_REGISTER_VP_SDNODE(SDOPC)                                          \
-  ASSERT_TRUE(ScopeOPC.hasValue());                                            \
-  ASSERT_EQ(ScopeOPC.getValue(), ISD::SDOPC);                                  \
+  ASSERT_TRUE(ScopeOPC.has_value());                                           \
+  ASSERT_EQ(*ScopeOPC, ISD::SDOPC);                                            \
   ScopeOPC = None;
 #include "llvm/IR/VPIntrinsics.def"
 
-  ASSERT_FALSE(ScopeVPID.hasValue());
-  ASSERT_FALSE(ScopeOPC.hasValue());
+  ASSERT_FALSE(ScopeVPID.has_value());
+  ASSERT_FALSE(ScopeOPC.has_value());
 }
 
 /// Check that every VP intrinsic in the test module is recognized as a VP
@@ -233,8 +233,8 @@ TEST_F(VPIntrinsicTest, GetParamPos) {
     ASSERT_TRUE(F.isIntrinsic());
     Optional<unsigned> MaskParamPos =
         VPIntrinsic::getMaskParamPos(F.getIntrinsicID());
-    if (MaskParamPos.hasValue()) {
-      Type *MaskParamType = F.getArg(MaskParamPos.getValue())->getType();
+    if (MaskParamPos) {
+      Type *MaskParamType = F.getArg(*MaskParamPos)->getType();
       ASSERT_TRUE(MaskParamType->isVectorTy());
       ASSERT_TRUE(
           cast<VectorType>(MaskParamType)->getElementType()->isIntegerTy(1));
@@ -242,8 +242,8 @@ TEST_F(VPIntrinsicTest, GetParamPos) {
 
     Optional<unsigned> VecLenParamPos =
         VPIntrinsic::getVectorLengthParamPos(F.getIntrinsicID());
-    if (VecLenParamPos.hasValue()) {
-      Type *VecLenParamType = F.getArg(VecLenParamPos.getValue())->getType();
+    if (VecLenParamPos) {
+      Type *VecLenParamType = F.getArg(*VecLenParamPos)->getType();
       ASSERT_TRUE(VecLenParamType->isIntegerTy(32));
     }
   }
@@ -406,13 +406,13 @@ TEST_F(VPIntrinsicTest, VPReductions) {
 
     if (!VPReductionIntrinsic::isVPReduction(ID)) {
       EXPECT_EQ(VPRedI, nullptr);
-      EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), false);
-      EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), false);
+      EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), false);
+      EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), false);
       continue;
     }
 
-    EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), true);
-    EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), true);
+    EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), true);
+    EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), true);
     ASSERT_NE(VPRedI, nullptr);
     EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID),
               VPRedI->getStartParamPos());
diff --git a/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp b/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
index 404dfd3..d347e17 100644
--- a/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
+++ b/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
@@ -47,9 +47,9 @@ TEST(ElfYamlTextAPI, YAMLReadableTBE) {
   ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
   std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
   EXPECT_NE(Stub.get(), nullptr);
-  EXPECT_FALSE(Stub->SoName.hasValue());
-  EXPECT_TRUE(Stub->Target.Arch.hasValue());
-  EXPECT_EQ(Stub->Target.Arch.getValue(), (uint16_t)llvm::ELF::EM_X86_64);
+  EXPECT_FALSE(Stub->SoName.has_value());
+  EXPECT_TRUE(Stub->Target.Arch.has_value());
+  EXPECT_EQ(Stub->Target.Arch.value(), (uint16_t)llvm::ELF::EM_X86_64);
   EXPECT_EQ(Stub->NeededLibs.size(), 3u);
   EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
   EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.so");
@@ -94,24 +94,24 @@ TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
   EXPECT_EQ(SymBaz.Type, IFSSymbolType::TLS);
   EXPECT_FALSE(SymBaz.Undefined);
   EXPECT_FALSE(SymBaz.Weak);
-  EXPECT_FALSE(SymBaz.Warning.hasValue());
+  EXPECT_FALSE(SymBaz.Warning.has_value());
 
   IFSSymbol const &SymFoo = *Iterator++;
   EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
-  EXPECT_FALSE(SymFoo.Size.hasValue());
+  EXPECT_FALSE(SymFoo.Size.has_value());
   EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func);
   EXPECT_FALSE(SymFoo.Undefined);
   EXPECT_FALSE(SymFoo.Weak);
-  EXPECT_TRUE(SymFoo.Warning.hasValue());
+  EXPECT_TRUE(SymFoo.Warning.has_value());
   EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");
 
   IFSSymbol const &SymNor = *Iterator++;
   EXPECT_STREQ(SymNor.Name.c_str(), "nor");
-  EXPECT_FALSE(SymNor.Size.hasValue());
+  EXPECT_FALSE(SymNor.Size.has_value());
   EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType);
   EXPECT_TRUE(SymNor.Undefined);
   EXPECT_FALSE(SymNor.Weak);
-  EXPECT_FALSE(SymNor.Warning.hasValue());
+  EXPECT_FALSE(SymNor.Warning.has_value());
 
   IFSSymbol const &SymNot = *Iterator++;
   EXPECT_STREQ(SymNot.Name.c_str(), "not");
diff --git a/llvm/unittests/Object/XCOFFObjectFileTest.cpp b/llvm/unittests/Object/XCOFFObjectFileTest.cpp
index 41662be..cf2be43 100644
--- a/llvm/unittests/Object/XCOFFObjectFileTest.cpp
+++ b/llvm/unittests/Object/XCOFFObjectFileTest.cpp
@@ -83,16 +83,16 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIGeneral) {
   EXPECT_TRUE(TT.hasParmsOnStack());
 
   ASSERT_TRUE(TT.getParmsType());
-  EXPECT_EQ(TT.getParmsType().getValue(), "i, f, d");
+  EXPECT_EQ(TT.getParmsType().value(), "i, f, d");
 
   ASSERT_TRUE(TT.getTraceBackTableOffset());
-  EXPECT_EQ(TT.getTraceBackTableOffset().getValue(), 64u);
+  EXPECT_EQ(TT.getTraceBackTableOffset().value(), 64u);
 
   EXPECT_FALSE(TT.getHandlerMask());
 
   ASSERT_TRUE(TT.getFunctionName());
-  EXPECT_EQ(TT.getFunctionName().getValue(), "add_all");
-  EXPECT_EQ(TT.getFunctionName().getValue().size(), 7u);
+  EXPECT_EQ(TT.getFunctionName().value(), "add_all");
+  EXPECT_EQ(TT.getFunctionName()->size(), 7u);
 
   EXPECT_FALSE(TT.getAllocaRegister());
   EXPECT_EQ(Size, 25u);
@@ -171,11 +171,11 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIControlledStorageInfoDisp) {
   XCOFFTracebackTable TT = *TTOrErr;
   EXPECT_TRUE(TT.hasControlledStorage());
   ASSERT_TRUE(TT.getNumOfCtlAnchors());
-  EXPECT_EQ(TT.getNumOfCtlAnchors().getValue(), 2u);
+  EXPECT_EQ(TT.getNumOfCtlAnchors().value(), 2u);
 
   ASSERT_TRUE(TT.getControlledStorageInfoDisp());
 
-  SmallVector<uint32_t, 8> Disp = TT.getControlledStorageInfoDisp().getValue();
+  SmallVector<uint32_t, 8> Disp = TT.getControlledStorageInfoDisp().value();
 
   ASSERT_EQ(Disp.size(), 2UL);
   EXPECT_EQ(Disp[0], 0x05050000u);
@@ -207,10 +207,10 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo) {
   EXPECT_TRUE(TT.hasExtensionTable());
 
   ASSERT_TRUE(TT.getParmsType());
-  EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i, v");
+  EXPECT_EQ(TT.getParmsType().value(), "v, i, f, i, d, i, v");
 
   ASSERT_TRUE(TT.getVectorExt());
-  TBVectorExt VecExt = TT.getVectorExt().getValue();
+  TBVectorExt VecExt = TT.getVectorExt().value();
 
   EXPECT_EQ(VecExt.getNumberOfVRSaved(), 0);
   EXPECT_TRUE(VecExt.isVRSavedOnStack());
@@ -240,10 +240,10 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo1) {
   XCOFFTracebackTable TT = *TTOrErr;
 
   ASSERT_TRUE(TT.getParmsType());
-  EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i, v, v");
+  EXPECT_EQ(TT.getParmsType().value(), "v, i, f, i, d, i, v, v");
 
   ASSERT_TRUE(TT.getVectorExt());
-  TBVectorExt VecExt = TT.getVectorExt().getValue();
+  TBVectorExt VecExt = TT.getVectorExt().value();
 
   EXPECT_EQ(VecExt.getNumberOfVRSaved(), 4);
   EXPECT_FALSE(VecExt.isVRSavedOnStack());
diff --git a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
index 91febff..09c9e35 100644
--- a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
+++ b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
@@ -91,8 +91,8 @@ debug_pubtypes:
   DWARFYAML::Data Data;
   ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
-  ASSERT_TRUE(Data.PubNames.hasValue());
-  DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
+  ASSERT_TRUE(Data.PubNames.has_value());
+  DWARFYAML::PubSection PubNames = Data.PubNames.value();
 
   ASSERT_EQ(PubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u);
@@ -100,8 +100,8 @@ debug_pubtypes:
   EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u);
   EXPECT_EQ(PubNames.Entries[1].Name, "def");
 
-  ASSERT_TRUE(Data.PubTypes.hasValue());
-  DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
+  ASSERT_TRUE(Data.PubTypes.has_value());
+  DWARFYAML::PubSection PubTypes = Data.PubTypes.value();
 
   ASSERT_EQ(PubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u);
@@ -157,8 +157,8 @@ debug_gnu_pubtypes:
   DWARFYAML::Data Data;
   ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
 
-  ASSERT_TRUE(Data.GNUPubNames.hasValue());
-  DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
+  ASSERT_TRUE(Data.GNUPubNames.has_value());
+  DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.value();
 
   ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u);
@@ -168,8 +168,8 @@ debug_gnu_pubtypes:
   EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34);
   EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
 
-  ASSERT_TRUE(Data.GNUPubTypes.hasValue());
-  DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
+  ASSERT_TRUE(Data.GNUPubTypes.has_value());
+  DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.value();
 
   ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);
   EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u);
diff --git a/llvm/unittests/ProfileData/MemProfTest.cpp b/llvm/unittests/ProfileData/MemProfTest.cpp
index 4808481..290d331 100644
--- a/llvm/unittests/ProfileData/MemProfTest.cpp
+++ b/llvm/unittests/ProfileData/MemProfTest.cpp
@@ -104,9 +104,9 @@ MATCHER_P4(FrameContains, FunctionName, LineOffset, Column, Inline, "") {
     *result_listener << "Hash mismatch";
     return false;
   }
-  if (F.SymbolName.hasValue() && F.SymbolName.getValue() != FunctionName) {
+  if (F.SymbolName && F.SymbolName.value() != FunctionName) {
     *result_listener << "SymbolName mismatch\nWant: " << FunctionName
-                     << "\nGot: " << F.SymbolName.getValue();
+                     << "\nGot: " << F.SymbolName.value();
     return false;
   }
   if (F.LineOffset == LineOffset && F.Column == Column &&
diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
index fa91997..fa26b60 100644
--- a/llvm/unittests/Support/AlignmentTest.cpp
+++ b/llvm/unittests/Support/AlignmentTest.cpp
@@ -63,11 +63,11 @@ TEST(AlignmentTest, ValidCTors) {
 
 TEST(AlignmentTest, CheckMaybeAlignHasValue) {
   EXPECT_TRUE(MaybeAlign(1));
-  EXPECT_TRUE(MaybeAlign(1).hasValue());
+  EXPECT_TRUE(MaybeAlign(1).has_value());
   EXPECT_FALSE(MaybeAlign(0));
-  EXPECT_FALSE(MaybeAlign(0).hasValue());
+  EXPECT_FALSE(MaybeAlign(0).has_value());
   EXPECT_FALSE(MaybeAlign());
-  EXPECT_FALSE(MaybeAlign().hasValue());
+  EXPECT_FALSE(MaybeAlign().has_value());
 }
 
 TEST(AlignmentTest, Division) {
@@ -165,8 +165,8 @@ TEST(AlignmentTest, isAligned_isAddrAligned) {
     MaybeAlign A(T.alignment);
     // Test Align
     if (A) {
-      EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned);
-      EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned);
+      EXPECT_EQ(isAligned(*A, T.offset), T.isAligned);
+      EXPECT_EQ(isAddrAligned(*A, T.forgedAddr()), T.isAligned);
     }
   }
 }
diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp
index 311fefd..bebb36f 100644
--- a/llvm/unittests/Support/Casting.cpp
+++ b/llvm/unittests/Support/Casting.cpp
@@ -248,11 +248,11 @@ TEST(CastingTest, dyn_cast_value_types) {
 TEST(CastingTest, dyn_cast_if_present) {
   Optional<T1> empty{};
   Optional<T2> F1 = dyn_cast_if_present<T2>(empty);
-  EXPECT_FALSE(F1.hasValue());
+  EXPECT_FALSE(F1.has_value());
 
   T1 t1;
   Optional<T2> F2 = dyn_cast_if_present<T2>(t1);
-  EXPECT_TRUE(F2.hasValue());
+  EXPECT_TRUE(F2.has_value());
 
   T1 *t1Null = nullptr;
 
diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp
index 9ef62bb..1411c2e 100644
--- a/llvm/unittests/Support/KnownBitsTest.cpp
+++ b/llvm/unittests/Support/KnownBitsTest.cpp
@@ -358,38 +358,38 @@ TEST(KnownBitsTest, ICmpExhaustive) {
       Optional<bool> KnownSLT = KnownBits::slt(Known1, Known2);
       Optional<bool> KnownSLE = KnownBits::sle(Known1, Known2);
 
-      EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.hasValue());
-      EXPECT_EQ(AllNE || NoneNE, KnownNE.hasValue());
-      EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.hasValue());
-      EXPECT_EQ(AllUGE || NoneUGE, KnownUGE.hasValue());
-      EXPECT_EQ(AllULT || NoneULT, KnownULT.hasValue());
-      EXPECT_EQ(AllULE || NoneULE, KnownULE.hasValue());
-      EXPECT_EQ(AllSGT || NoneSGT, KnownSGT.hasValue());
-      EXPECT_EQ(AllSGE || NoneSGE, KnownSGE.hasValue());
-      EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.hasValue());
-      EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.hasValue());
-
-      EXPECT_EQ(AllEQ, KnownEQ.hasValue() && KnownEQ.getValue());
-      EXPECT_EQ(AllNE, KnownNE.hasValue() && KnownNE.getValue());
-      EXPECT_EQ(AllUGT, KnownUGT.hasValue() && KnownUGT.getValue());
-      EXPECT_EQ(AllUGE, KnownUGE.hasValue() && KnownUGE.getValue());
-      EXPECT_EQ(AllULT, KnownULT.hasValue() && KnownULT.getValue());
-      EXPECT_EQ(AllULE, KnownULE.hasValue() && KnownULE.getValue());
-      EXPECT_EQ(AllSGT, KnownSGT.hasValue() && KnownSGT.getValue());
-      EXPECT_EQ(AllSGE, KnownSGE.hasValue() && KnownSGE.getValue());
-      EXPECT_EQ(AllSLT, KnownSLT.hasValue() && KnownSLT.getValue());
-      EXPECT_EQ(AllSLE, KnownSLE.hasValue() && KnownSLE.getValue());
-
-      EXPECT_EQ(NoneEQ, KnownEQ.hasValue() && !KnownEQ.getValue());
-      EXPECT_EQ(NoneNE, KnownNE.hasValue() && !KnownNE.getValue());
-      EXPECT_EQ(NoneUGT, KnownUGT.hasValue() && !KnownUGT.getValue());
-      EXPECT_EQ(NoneUGE, KnownUGE.hasValue() && !KnownUGE.getValue());
-      EXPECT_EQ(NoneULT, KnownULT.hasValue() && !KnownULT.getValue());
-      EXPECT_EQ(NoneULE, KnownULE.hasValue() && !KnownULE.getValue());
-      EXPECT_EQ(NoneSGT, KnownSGT.hasValue() && !KnownSGT.getValue());
-      EXPECT_EQ(NoneSGE, KnownSGE.hasValue() && !KnownSGE.getValue());
-      EXPECT_EQ(NoneSLT, KnownSLT.hasValue() && !KnownSLT.getValue());
-      EXPECT_EQ(NoneSLE, KnownSLE.hasValue() && !KnownSLE.getValue());
+      EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.has_value());
+      EXPECT_EQ(AllNE || NoneNE, KnownNE.has_value());
+      EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.has_value());
+      EXPECT_EQ(AllUGE || NoneUGE, KnownUGE.has_value());
+      EXPECT_EQ(AllULT || NoneULT, KnownULT.has_value());
+      EXPECT_EQ(AllULE || NoneULE, KnownULE.has_value());
+      EXPECT_EQ(AllSGT || NoneSGT, KnownSGT.has_value());
+      EXPECT_EQ(AllSGE || NoneSGE, KnownSGE.has_value());
+      EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.has_value());
+      EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.has_value());
+
+      EXPECT_EQ(AllEQ, KnownEQ && *KnownEQ);
+      EXPECT_EQ(AllNE, KnownNE && *KnownNE);
+      EXPECT_EQ(AllUGT, KnownUGT && *KnownUGT);
+      EXPECT_EQ(AllUGE, KnownUGE && *KnownUGE);
+      EXPECT_EQ(AllULT, KnownULT && *KnownULT);
+      EXPECT_EQ(AllULE, KnownULE && *KnownULE);
+      EXPECT_EQ(AllSGT, KnownSGT && *KnownSGT);
+      EXPECT_EQ(AllSGE, KnownSGE && *KnownSGE);
+      EXPECT_EQ(AllSLT, KnownSLT && *KnownSLT);
+      EXPECT_EQ(AllSLE, KnownSLE && *KnownSLE);
+
+      EXPECT_EQ(NoneEQ, KnownEQ && !*KnownEQ);
+      EXPECT_EQ(NoneNE, KnownNE && !*KnownNE);
+      EXPECT_EQ(NoneUGT, KnownUGT && !*KnownUGT);
+      EXPECT_EQ(NoneUGE, KnownUGE && !*KnownUGE);
+      EXPECT_EQ(NoneULT, KnownULT && !*KnownULT);
+      EXPECT_EQ(NoneULE, KnownULE && !*KnownULE);
+      EXPECT_EQ(NoneSGT, KnownSGT && !*KnownSGT);
+      EXPECT_EQ(NoneSGE, KnownSGE && !*KnownSGE);
+      EXPECT_EQ(NoneSLT, KnownSLT && !*KnownSLT);
+      EXPECT_EQ(NoneSLE, KnownSLE && !*KnownSLE);
     });
   });
 }
diff --git a/llvm/unittests/Support/YAMLParserTest.cpp b/llvm/unittests/Support/YAMLParserTest.cpp
index 692d963..14def9c 100644
--- a/llvm/unittests/Support/YAMLParserTest.cpp
+++ b/llvm/unittests/Support/YAMLParserTest.cpp
@@ -344,12 +344,12 @@ TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) {
 
 static void expectCanParseBool(StringRef S, bool Expected) {
   llvm::Optional<bool> Parsed = yaml::parseBool(S);
-  EXPECT_TRUE(Parsed.hasValue());
+  EXPECT_TRUE(Parsed.has_value());
   EXPECT_EQ(*Parsed, Expected);
 }
 
 static void expectCannotParseBool(StringRef S) {
-  EXPECT_FALSE(yaml::parseBool(S).hasValue());
+  EXPECT_FALSE(yaml::parseBool(S).has_value());
 }
 
 TEST(YAMLParser, ParsesBools) {
diff --git a/llvm/unittests/TableGen/ParserEntryPointTest.cpp b/llvm/unittests/TableGen/ParserEntryPointTest.cpp
index 23642b6..a227f3d 100644
--- a/llvm/unittests/TableGen/ParserEntryPointTest.cpp
+++ b/llvm/unittests/TableGen/ParserEntryPointTest.cpp
@@ -35,6 +35,6 @@ TEST(Parser, SanityTest) {
 
   Record *Foo = Records.getDef("Foo");
   Optional<StringRef> Field = Foo->getValueAsOptionalString("strField");
-  EXPECT_TRUE(Field.hasValue());
-  EXPECT_EQ(Field.getValue(), "value");
+  EXPECT_TRUE(Field.has_value());
+  EXPECT_EQ(*Field, "value");
 }