[llvm] 3361a36 - [llvm] Use has_value instead of hasValue (NFC)
Kazu Hirata via llvm-commits
llvm-commits at lists.llvm.org
Tue Jul 12 22:25:49 PDT 2022
Author: Kazu Hirata
Date: 2022-07-12T22:25:42-07:00
New Revision: 3361a364e64c815ede2fe6dfe4e8016637c16b0b
URL: https://github.com/llvm/llvm-project/commit/3361a364e64c815ede2fe6dfe4e8016637c16b0b
DIFF: https://github.com/llvm/llvm-project/commit/3361a364e64c815ede2fe6dfe4e8016637c16b0b.diff
LOG: [llvm] Use has_value instead of hasValue (NFC)
Added:
Modified:
llvm/include/llvm/MC/MCDwarf.h
llvm/unittests/ADT/OptionalTest.cpp
llvm/unittests/ADT/StatisticTest.cpp
llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
llvm/unittests/BinaryFormat/DwarfTest.cpp
llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
llvm/unittests/IR/MetadataTest.cpp
llvm/unittests/IR/VPIntrinsicTest.cpp
llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
llvm/unittests/Support/AlignmentTest.cpp
llvm/unittests/Support/Casting.cpp
llvm/unittests/Support/KnownBitsTest.cpp
llvm/unittests/Support/YAMLParserTest.cpp
llvm/unittests/TableGen/ParserEntryPointTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/MC/MCDwarf.h b/llvm/include/llvm/MC/MCDwarf.h
index ce65b173b3d24..8b2ae84749b4f 100644
--- a/llvm/include/llvm/MC/MCDwarf.h
+++ b/llvm/include/llvm/MC/MCDwarf.h
@@ -374,8 +374,8 @@ class MCDwarfLineTable {
Header.RootFile.DirIndex = 0;
Header.RootFile.Checksum = Checksum;
Header.RootFile.Source = Source;
- Header.trackMD5Usage(Checksum.hasValue());
- Header.HasSource = Source.hasValue();
+ Header.trackMD5Usage(Checksum.has_value());
+ Header.HasSource = Source.has_value();
}
void resetFileTable() { Header.resetFileTable(); }
diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp
index f88437f0ab294..dc1e073d93cfa 100644
--- a/llvm/unittests/ADT/OptionalTest.cpp
+++ b/llvm/unittests/ADT/OptionalTest.cpp
@@ -29,7 +29,7 @@ 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};
@@ -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 17d9911915550..523f510cccdde 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/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
index cfe2c25fc8393..f6a053792f852 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/BinaryFormat/DwarfTest.cpp b/llvm/unittests/BinaryFormat/DwarfTest.cpp
index 5e49a5cc2ee68..ddafbb4102bde 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 5053d542d2bac..d1d10a3f0c339 100644
--- a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
+++ b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
@@ -83,156 +83,156 @@ TEST_F(AArch64GISelMITest, FoldBinOp) {
Optional<APInt> FoldGAddInt =
ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGAddInt.hasValue());
+ EXPECT_TRUE(FoldGAddInt.has_value());
EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue());
Optional<APInt> FoldGAddMix =
ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGAddMix.hasValue());
+ EXPECT_TRUE(FoldGAddMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGAddMix.getValue().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_TRUE(FoldGAndInt.has_value());
EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue());
Optional<APInt> FoldGAndMix =
ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst2.getReg(0),
MIBFCst1.getReg(0), *MRI);
- EXPECT_TRUE(FoldGAndMix.hasValue());
+ EXPECT_TRUE(FoldGAndMix.has_value());
EXPECT_EQ(1ULL, FoldGAndMix.getValue().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_TRUE(FoldGAShrInt.has_value());
EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue());
Optional<APInt> FoldGAShrMix =
ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBFCst2.getReg(0),
MIBCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGAShrMix.hasValue());
+ EXPECT_TRUE(FoldGAShrMix.has_value());
EXPECT_EQ(2097152ULL, FoldGAShrMix.getValue().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_TRUE(FoldGLShrInt.has_value());
EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue());
Optional<APInt> FoldGLShrMix =
ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBFCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGLShrMix.hasValue());
+ EXPECT_TRUE(FoldGLShrMix.has_value());
EXPECT_EQ(2080768ULL, FoldGLShrMix.getValue().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_TRUE(FoldGMulInt.has_value());
EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue());
Optional<APInt> FoldGMulMix =
ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGMulMix.hasValue());
+ EXPECT_TRUE(FoldGMulMix.has_value());
EXPECT_EQ(0ULL, FoldGMulMix.getValue().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_TRUE(FoldGOrInt.has_value());
EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue());
Optional<APInt> FoldGOrMix =
ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGOrMix.hasValue());
+ EXPECT_TRUE(FoldGOrMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGOrMix.getValue().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_TRUE(FoldGShlInt.has_value());
EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue());
Optional<APInt> FoldGShlMix =
ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGShlMix.hasValue());
+ EXPECT_TRUE(FoldGShlMix.has_value());
EXPECT_EQ(0ULL, FoldGShlMix.getValue().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_TRUE(FoldGSubInt.has_value());
EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue());
Optional<APInt> FoldGSubMix =
ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGSubMix.hasValue());
+ EXPECT_TRUE(FoldGSubMix.has_value());
EXPECT_EQ(3221225488ULL, FoldGSubMix.getValue().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_TRUE(FoldGXorInt.has_value());
EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue());
Optional<APInt> FoldGXorMix =
ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGXorMix.hasValue());
+ EXPECT_TRUE(FoldGXorMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGXorMix.getValue().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_TRUE(FoldGUdivInt.has_value());
EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue());
Optional<APInt> FoldGUdivMix =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGUdivMix.hasValue());
+ EXPECT_TRUE(FoldGUdivMix.has_value());
EXPECT_EQ(0ULL, FoldGUdivMix.getValue().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_TRUE(FoldGSdivInt.has_value());
EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue());
Optional<APInt> FoldGSdivMix =
ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGSdivMix.hasValue());
+ EXPECT_TRUE(FoldGSdivMix.has_value());
EXPECT_EQ(0ULL, FoldGSdivMix.getValue().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_TRUE(FoldGUremInt.has_value());
EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue());
Optional<APInt> FoldGUremMix =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGUremMix.hasValue());
+ EXPECT_TRUE(FoldGUremMix.has_value());
EXPECT_EQ(0ULL, FoldGUremMix.getValue().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_TRUE(FoldGSremInt.has_value());
EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue());
Optional<APInt> FoldGSremMix =
ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
- EXPECT_TRUE(FoldGSremMix.hasValue());
+ EXPECT_TRUE(FoldGSremMix.has_value());
EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
}
diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
index 6a8f23c05a576..dbc54e7bdb8ef 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 367e89e4970d3..3d2e084292294 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
@@ -252,7 +252,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
- EXPECT_TRUE(BlockDataOpt.hasValue());
+ EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@@ -260,7 +260,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block1);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
- EXPECT_TRUE(BlockDataOpt.hasValue());
+ EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@@ -268,7 +268,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block2);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
- EXPECT_TRUE(BlockDataOpt.hasValue());
+ EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@@ -276,7 +276,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block4);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
- EXPECT_TRUE(BlockDataOpt.hasValue());
+ EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@@ -286,7 +286,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_data16);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
- EXPECT_TRUE(BlockDataOpt.hasValue());
+ EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), 16u);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0);
@@ -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 9976777005a18..1a89025a00dbc 100644
--- a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
+++ b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
@@ -89,7 +89,7 @@ TEST(DWARFFormValue, SignedConstantForms) {
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(TooBig.getAsSignedConstant().has_value(), false);
// Sanity check some other forms.
auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120);
diff --git a/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp b/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
index 977231d81143a..bfe66f0cef1c2 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/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp
index 80657d3b7ac77..5b64861ec0dbf 100644
--- a/llvm/unittests/IR/MetadataTest.cpp
+++ b/llvm/unittests/IR/MetadataTest.cpp
@@ -2933,22 +2933,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 +3457,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 b403b428f956c..d5f033d50f646 100644
--- a/llvm/unittests/IR/VPIntrinsicTest.cpp
+++ b/llvm/unittests/IR/VPIntrinsicTest.cpp
@@ -128,25 +128,25 @@ class VPIntrinsicTest : public testing::Test {
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_TRUE(ScopeVPID.has_value()); \
ASSERT_EQ(ScopeVPID.getValue(), 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_TRUE(ScopeOPC.has_value()); \
ASSERT_EQ(ScopeOPC.getValue(), 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
@@ -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 404dfd3e6b686..d8c66858bcd32 100644
--- a/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
+++ b/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
@@ -47,8 +47,8 @@ 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_FALSE(Stub->SoName.has_value());
+ EXPECT_TRUE(Stub->Target.Arch.has_value());
EXPECT_EQ(Stub->Target.Arch.getValue(), (uint16_t)llvm::ELF::EM_X86_64);
EXPECT_EQ(Stub->NeededLibs.size(), 3u);
EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.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/ObjectYAML/DWARFYAMLTest.cpp b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
index 91febffdfcc3a..badbda946d362 100644
--- a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
+++ b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
@@ -91,7 +91,7 @@ TEST(DebugPubSection, TestDebugPubSection) {
DWARFYAML::Data Data;
ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
- ASSERT_TRUE(Data.PubNames.hasValue());
+ ASSERT_TRUE(Data.PubNames.has_value());
DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
ASSERT_EQ(PubNames.Entries.size(), 2u);
@@ -100,7 +100,7 @@ TEST(DebugPubSection, TestDebugPubSection) {
EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u);
EXPECT_EQ(PubNames.Entries[1].Name, "def");
- ASSERT_TRUE(Data.PubTypes.hasValue());
+ ASSERT_TRUE(Data.PubTypes.has_value());
DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
ASSERT_EQ(PubTypes.Entries.size(), 2u);
@@ -157,7 +157,7 @@ TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
DWARFYAML::Data Data;
ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
- ASSERT_TRUE(Data.GNUPubNames.hasValue());
+ ASSERT_TRUE(Data.GNUPubNames.has_value());
DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
@@ -168,7 +168,7 @@ TEST(DebugGNUPubSection, TestDebugGNUPubSections) {
EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34);
EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
- ASSERT_TRUE(Data.GNUPubTypes.hasValue());
+ ASSERT_TRUE(Data.GNUPubTypes.has_value());
DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);
diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
index 0860514bcc384..6bd9b52620738 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 311fefd728785..bebb36fc61f22 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 9ef62bb90fcc4..6dcea6dbf0726 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 692d963828318..14def9c528875 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 23642b6fd751c..63bbc51286b1c 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_TRUE(Field.has_value());
EXPECT_EQ(Field.getValue(), "value");
}
More information about the llvm-commits
mailing list