[llvm] Use has_value instead of hasValue (NFC)

4 files changed, 39 insertions, 39 deletions

diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
index 0860514..6bd9b52 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) {
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..6dcea6db 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.has_value() && KnownEQ.getValue());
+      EXPECT_EQ(AllNE, KnownNE.has_value() && KnownNE.getValue());
+      EXPECT_EQ(AllUGT, KnownUGT.has_value() && KnownUGT.getValue());
+      EXPECT_EQ(AllUGE, KnownUGE.has_value() && KnownUGE.getValue());
+      EXPECT_EQ(AllULT, KnownULT.has_value() && KnownULT.getValue());
+      EXPECT_EQ(AllULE, KnownULE.has_value() && KnownULE.getValue());
+      EXPECT_EQ(AllSGT, KnownSGT.has_value() && KnownSGT.getValue());
+      EXPECT_EQ(AllSGE, KnownSGE.has_value() && KnownSGE.getValue());
+      EXPECT_EQ(AllSLT, KnownSLT.has_value() && KnownSLT.getValue());
+      EXPECT_EQ(AllSLE, KnownSLE.has_value() && KnownSLE.getValue());
+
+      EXPECT_EQ(NoneEQ, KnownEQ.has_value() && !KnownEQ.getValue());
+      EXPECT_EQ(NoneNE, KnownNE.has_value() && !KnownNE.getValue());
+      EXPECT_EQ(NoneUGT, KnownUGT.has_value() && !KnownUGT.getValue());
+      EXPECT_EQ(NoneUGE, KnownUGE.has_value() && !KnownUGE.getValue());
+      EXPECT_EQ(NoneULT, KnownULT.has_value() && !KnownULT.getValue());
+      EXPECT_EQ(NoneULE, KnownULE.has_value() && !KnownULE.getValue());
+      EXPECT_EQ(NoneSGT, KnownSGT.has_value() && !KnownSGT.getValue());
+      EXPECT_EQ(NoneSGE, KnownSGE.has_value() && !KnownSGE.getValue());
+      EXPECT_EQ(NoneSLT, KnownSLT.has_value() && !KnownSLT.getValue());
+      EXPECT_EQ(NoneSLE, KnownSLE.has_value() && !KnownSLE.getValue());
     });
   });
 }
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) {