diff options
Diffstat (limited to 'llvm/unittests')
28 files changed, 137 insertions, 138 deletions
diff --git a/llvm/unittests/ADT/ArrayRefTest.cpp b/llvm/unittests/ADT/ArrayRefTest.cpp index 9fcddc8..0aea5a9 100644 --- a/llvm/unittests/ADT/ArrayRefTest.cpp +++ b/llvm/unittests/ADT/ArrayRefTest.cpp @@ -44,9 +44,9 @@ namespace { TEST(ArrayRefTest, AllocatorCopy) { BumpPtrAllocator Alloc; static const uint16_t Words1[] = { 1, 4, 200, 37 }; - ArrayRef<uint16_t> Array1 = makeArrayRef(Words1, 4); + ArrayRef<uint16_t> Array1 = ArrayRef(Words1, 4); static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 }; - ArrayRef<uint16_t> Array2 = makeArrayRef(Words2, 5); + ArrayRef<uint16_t> Array2 = ArrayRef(Words2, 5); ArrayRef<uint16_t> Array1c = Array1.copy(Alloc); ArrayRef<uint16_t> Array2c = Array2.copy(Alloc); EXPECT_TRUE(Array1.equals(Array1c)); @@ -63,9 +63,9 @@ TEST(ArrayRefTest, AllocatorCopy) { void operator=(const NonAssignable &RHS) { assert(RHS.Ptr != nullptr); } bool operator==(const NonAssignable &RHS) const { return Ptr == RHS.Ptr; } } Array3Src[] = {"hello", "world"}; - ArrayRef<NonAssignable> Array3Copy = makeArrayRef(Array3Src).copy(Alloc); - EXPECT_EQ(makeArrayRef(Array3Src), Array3Copy); - EXPECT_NE(makeArrayRef(Array3Src).data(), Array3Copy.data()); + ArrayRef<NonAssignable> Array3Copy = ArrayRef(Array3Src).copy(Alloc); + EXPECT_EQ(ArrayRef(Array3Src), Array3Copy); + EXPECT_NE(ArrayRef(Array3Src).data(), Array3Copy.data()); } // This test is pure UB given the ArrayRef<> implementation. @@ -222,31 +222,32 @@ TEST(ArrayRefTest, EmptyInitializerList) { EXPECT_TRUE(A.empty()); } -TEST(ArrayRefTest, makeArrayRef) { +TEST(ArrayRefTest, ArrayRef) { static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; - // No copy expected for non-const ArrayRef (true no-op) + // A copy is expected for non-const ArrayRef (thin copy) ArrayRef<int> AR1(A1); - ArrayRef<int> &AR1Ref = makeArrayRef(AR1); - EXPECT_EQ(&AR1, &AR1Ref); + const ArrayRef<int> &AR1Ref = ArrayRef(AR1); + EXPECT_NE(&AR1, &AR1Ref); + EXPECT_TRUE(AR1.equals(AR1Ref)); // A copy is expected for non-const ArrayRef (thin copy) const ArrayRef<int> AR2(A1); - const ArrayRef<int> &AR2Ref = makeArrayRef(AR2); + const ArrayRef<int> &AR2Ref = ArrayRef(AR2); EXPECT_NE(&AR2Ref, &AR2); EXPECT_TRUE(AR2.equals(AR2Ref)); } TEST(ArrayRefTest, OwningArrayRef) { static const int A1[] = {0, 1}; - OwningArrayRef<int> A(makeArrayRef(A1)); + OwningArrayRef<int> A{ArrayRef(A1)}; OwningArrayRef<int> B(std::move(A)); EXPECT_EQ(A.data(), nullptr); } -TEST(ArrayRefTest, makeArrayRefFromStdArray) { +TEST(ArrayRefTest, ArrayRefFromStdArray) { std::array<int, 5> A1{{42, -5, 0, 1000000, -1000000}}; - ArrayRef<int> A2 = makeArrayRef(A1); + ArrayRef<int> A2 = ArrayRef(A1); EXPECT_EQ(A1.size(), A2.size()); for (std::size_t i = 0; i < A1.size(); ++i) { diff --git a/llvm/unittests/ADT/EditDistanceTest.cpp b/llvm/unittests/ADT/EditDistanceTest.cpp index 6e35f1b5..84c8532 100644 --- a/llvm/unittests/ADT/EditDistanceTest.cpp +++ b/llvm/unittests/ADT/EditDistanceTest.cpp @@ -29,8 +29,8 @@ static Result editDistanceAndMaps(StringRef A, StringRef B, return X; }; unsigned EditDist = llvm::ComputeMappedEditDistance( - makeArrayRef(A.data(), A.size()), makeArrayRef(B.data(), B.size()), - TrackMaps, true, MaxEditDistance); + ArrayRef(A.data(), A.size()), ArrayRef(B.data(), B.size()), TrackMaps, + true, MaxEditDistance); return {NumMaps, EditDist}; } diff --git a/llvm/unittests/ADT/SmallVectorTest.cpp b/llvm/unittests/ADT/SmallVectorTest.cpp index 62e6f433..fd3780a 100644 --- a/llvm/unittests/ADT/SmallVectorTest.cpp +++ b/llvm/unittests/ADT/SmallVectorTest.cpp @@ -1128,18 +1128,18 @@ TEST(SmallVectorTest, InitializerList) { SmallVector<int, 2> V1 = {}; EXPECT_TRUE(V1.empty()); V1 = {0, 0}; - EXPECT_TRUE(makeArrayRef(V1).equals({0, 0})); + EXPECT_TRUE(ArrayRef(V1).equals({0, 0})); V1 = {-1, -1}; - EXPECT_TRUE(makeArrayRef(V1).equals({-1, -1})); + EXPECT_TRUE(ArrayRef(V1).equals({-1, -1})); SmallVector<int, 2> V2 = {1, 2, 3, 4}; - EXPECT_TRUE(makeArrayRef(V2).equals({1, 2, 3, 4})); + EXPECT_TRUE(ArrayRef(V2).equals({1, 2, 3, 4})); V2.assign({4}); - EXPECT_TRUE(makeArrayRef(V2).equals({4})); + EXPECT_TRUE(ArrayRef(V2).equals({4})); V2.append({3, 2}); - EXPECT_TRUE(makeArrayRef(V2).equals({4, 3, 2})); + EXPECT_TRUE(ArrayRef(V2).equals({4, 3, 2})); V2.insert(V2.begin() + 1, 5); - EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2})); + EXPECT_TRUE(ArrayRef(V2).equals({4, 5, 3, 2})); } TEST(SmallVectorTest, ToVector) { diff --git a/llvm/unittests/ADT/TinyPtrVectorTest.cpp b/llvm/unittests/ADT/TinyPtrVectorTest.cpp index b3c03cb..af4ae4f 100644 --- a/llvm/unittests/ADT/TinyPtrVectorTest.cpp +++ b/llvm/unittests/ADT/TinyPtrVectorTest.cpp @@ -53,9 +53,7 @@ protected: PtrT makePtr(ValueT *V) { return PtrT(V); } - ArrayRef<PtrT> testArray(size_t N) { - return makeArrayRef(&TestPtrs[0], N); - } + ArrayRef<PtrT> testArray(size_t N) { return ArrayRef(&TestPtrs[0], N); } void appendValues(VectorT &V, ArrayRef<PtrT> Values) { for (size_t i = 0, e = Values.size(); i != e; ++i) diff --git a/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp b/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp index be3b041..ffe822e 100644 --- a/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp +++ b/llvm/unittests/Analysis/MemoryProfileInfoTest.cpp @@ -407,10 +407,10 @@ declare noundef nonnull ptr @_Znam(i64 noundef) StackIds.push_back(*ContextIter); if (First) { std::vector<uint64_t> Expected = {2, 3, 4}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } else { std::vector<uint64_t> Expected = {2, 3, 5}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } First = false; } @@ -435,10 +435,10 @@ TEST_F(MemoryProfileInfoTest, CallStackTestSummary) { StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex)); if (First) { std::vector<uint64_t> Expected = {3, 4}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } else { std::vector<uint64_t> Expected = {3, 5}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } First = false; } @@ -455,10 +455,10 @@ TEST_F(MemoryProfileInfoTest, CallStackTestSummary) { StackIds.push_back(Index->getStackIdAtIndex(StackIdIndex)); if (First) { std::vector<uint64_t> Expected = {1, 2, 3, 4}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } else { std::vector<uint64_t> Expected = {1, 2, 3, 5}; - EXPECT_EQ(makeArrayRef(StackIds), makeArrayRef(Expected)); + EXPECT_EQ(ArrayRef(StackIds), ArrayRef(Expected)); } First = false; } diff --git a/llvm/unittests/Analysis/VectorUtilsTest.cpp b/llvm/unittests/Analysis/VectorUtilsTest.cpp index 6d08722..c7419e0 100644 --- a/llvm/unittests/Analysis/VectorUtilsTest.cpp +++ b/llvm/unittests/Analysis/VectorUtilsTest.cpp @@ -105,9 +105,10 @@ TEST_F(BasicTest, isSplat) { TEST_F(BasicTest, narrowShuffleMaskElts) { SmallVector<int, 16> ScaledMask; narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask); - EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({3,2,0,-2})); + EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({3, 2, 0, -2})); narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask); - EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1})); + EXPECT_EQ(ArrayRef(ScaledMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1, + 2, 3, -1, -1, -1, -1})); } TEST_F(BasicTest, widenShuffleMaskElts) { @@ -116,11 +117,11 @@ TEST_F(BasicTest, widenShuffleMaskElts) { // scale == 1 is a copy EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask)); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1})); // back to original mask - narrowShuffleMaskElts(1, makeArrayRef(WideMask), NarrowMask); - EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({3,2,0,-1})); + narrowShuffleMaskElts(1, ArrayRef(WideMask), NarrowMask); + EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({3, 2, 0, -1})); // can't widen non-consecutive 3/2 EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask)); @@ -130,30 +131,31 @@ TEST_F(BasicTest, widenShuffleMaskElts) { // can always widen identity to single element EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask)); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0})); // back to original mask - narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask); - EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({0,1,2})); + narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask); + EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({0, 1, 2})); // groups of 4 must be consecutive/undef EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask)); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1})); // back to original mask - narrowShuffleMaskElts(4, makeArrayRef(WideMask), NarrowMask); - EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1})); + narrowShuffleMaskElts(4, ArrayRef(WideMask), NarrowMask); + EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({12, 13, 14, 15, 8, 9, 10, 11, 0, 1, + 2, 3, -1, -1, -1, -1})); // groups of 2 must be consecutive/undef EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask)); // groups of 3 must be consecutive/undef EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask)); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2,0,-1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1})); // back to original mask - narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask); - EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({6,7,8,0,1,2,-1,-1,-1})); + narrowShuffleMaskElts(3, ArrayRef(WideMask), NarrowMask); + EXPECT_EQ(ArrayRef(NarrowMask), ArrayRef({6, 7, 8, 0, 1, 2, -1, -1, -1})); // groups of 3 must be consecutive/undef (partial undefs are not ok) EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask)); @@ -163,7 +165,7 @@ TEST_F(BasicTest, widenShuffleMaskElts) { // negative indexes must match across a wide element EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask)); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2,-3})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3})); } TEST_F(BasicTest, getShuffleMaskWithWidestElts) { @@ -171,43 +173,42 @@ TEST_F(BasicTest, getShuffleMaskWithWidestElts) { // can not widen anything here. getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1})); // can't widen non-consecutive 3/2 getShuffleMaskWithWidestElts({3, 2, 0, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1})); // can always widen identity to single element getShuffleMaskWithWidestElts({0, 1, 2}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({0})); // groups of 4 must be consecutive/undef getShuffleMaskWithWidestElts( {12, 13, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3, 2, 0, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({3, 2, 0, -1})); // groups of 2 must be consecutive/undef getShuffleMaskWithWidestElts( {12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, 3, -1, -1, -1, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({12, 12, 14, 15, 8, 9, 10, 11, - 0, 1, 2, 3, -1, -1, -1, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({12, 12, 14, 15, 8, 9, 10, 11, 0, 1, 2, + 3, -1, -1, -1, -1})); // groups of 3 must be consecutive/undef getShuffleMaskWithWidestElts({6, 7, 8, 0, 1, 2, -1, -1, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2, 0, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({2, 0, -1})); // groups of 3 must be consecutive/undef (partial undefs are not ok) getShuffleMaskWithWidestElts({-1, 7, 8, 0, -1, 2, -1, -1, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), - makeArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, 7, 8, 0, -1, 2, -1, -1, -1})); // negative indexes must match across a wide element getShuffleMaskWithWidestElts({-1, -2, -1, -1}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-1, -2, -1, -1})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-1, -2, -1, -1})); // negative indexes must match across a wide element getShuffleMaskWithWidestElts({-2, -2, -3, -3}, WideMask); - EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2, -3})); + EXPECT_EQ(ArrayRef(WideMask), ArrayRef({-2, -3})); } TEST_F(BasicTest, getShuffleDemandedElts) { diff --git a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp index f9056f0..0686ac4 100644 --- a/llvm/unittests/Bitstream/BitstreamReaderTest.cpp +++ b/llvm/unittests/Bitstream/BitstreamReaderTest.cpp @@ -108,7 +108,7 @@ TEST(BitstreamReaderTest, readRecordWithBlobWhileStreaming) { Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); AbbrevID = Stream.EmitAbbrev(std::move(Abbrev)); unsigned Record[] = {RecordID}; - Stream.EmitRecordWithBlob(AbbrevID, makeArrayRef(Record), BlobIn); + Stream.EmitRecordWithBlob(AbbrevID, ArrayRef(Record), BlobIn); Stream.ExitBlock(); } diff --git a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp index 588d51a..60fb14d 100644 --- a/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp +++ b/llvm/unittests/DebugInfo/MSF/MappedBlockStreamTest.cpp @@ -493,7 +493,7 @@ TEST(MappedBlockStreamTest, DataLivesAfterStreamDestruction) { MATCHER_P3(BlockIsFilledWith, Layout, BlockIndex, Byte, "succeeded") { uint64_t Offset = msf::blockToOffset(BlockIndex, Layout.SB->BlockSize); - ArrayRef<uint8_t> BufferRef = makeArrayRef(arg); + ArrayRef<uint8_t> BufferRef = ArrayRef(arg); BufferRef = BufferRef.slice(Offset, Layout.SB->BlockSize); return llvm::all_of(BufferRef, [this](uint8_t B) { return B == Byte; }); } diff --git a/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp b/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp index 45ba42e..bc1d60e 100644 --- a/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp +++ b/llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp @@ -302,7 +302,7 @@ TEST(RandomIRBuilderTest, dontConnectToSwitch) { // Choose an instruction and connect to later operations. size_t IP = uniform<size_t>(IB.Rand, 1, Insts.size() - 1); Instruction *Inst = Insts[IP - 1]; - auto ConnectAfter = makeArrayRef(Insts).slice(IP); + auto ConnectAfter = ArrayRef(Insts).slice(IP); IB.connectToSink(*BB, ConnectAfter, Inst); ASSERT_FALSE(verifyModule(*M, &errs())); } diff --git a/llvm/unittests/IR/AttributesTest.cpp b/llvm/unittests/IR/AttributesTest.cpp index 832af6e..fcd7a22 100644 --- a/llvm/unittests/IR/AttributesTest.cpp +++ b/llvm/unittests/IR/AttributesTest.cpp @@ -201,9 +201,9 @@ TEST(Attributes, HasParentContext) { { AttributeSet AS1 = AttributeSet::get( - C1, makeArrayRef(Attribute::get(C1, Attribute::NoReturn))); + C1, ArrayRef(Attribute::get(C1, Attribute::NoReturn))); AttributeSet AS2 = AttributeSet::get( - C2, makeArrayRef(Attribute::get(C2, Attribute::NoReturn))); + C2, ArrayRef(Attribute::get(C2, Attribute::NoReturn))); EXPECT_TRUE(AS1.hasParentContext(C1)); EXPECT_FALSE(AS1.hasParentContext(C2)); EXPECT_FALSE(AS2.hasParentContext(C1)); diff --git a/llvm/unittests/IR/DebugInfoTest.cpp b/llvm/unittests/IR/DebugInfoTest.cpp index 8a5157f..8e504d5 100644 --- a/llvm/unittests/IR/DebugInfoTest.cpp +++ b/llvm/unittests/IR/DebugInfoTest.cpp @@ -84,7 +84,7 @@ TEST(DINodeTest, splitFlags) { { \ SmallVector<DINode::DIFlags, 8> V; \ EXPECT_EQ(REMAINDER, DINode::splitFlags(FLAGS, V)); \ - EXPECT_TRUE(makeArrayRef(V).equals(VECTOR)); \ + EXPECT_TRUE(ArrayRef(V).equals(VECTOR)); \ } CHECK_SPLIT(DINode::FlagPublic, {DINode::FlagPublic}, DINode::FlagZero); CHECK_SPLIT(DINode::FlagProtected, {DINode::FlagProtected}, DINode::FlagZero); diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp index 926490f..f8a796a 100644 --- a/llvm/unittests/IR/MetadataTest.cpp +++ b/llvm/unittests/IR/MetadataTest.cpp @@ -2931,7 +2931,7 @@ typedef MetadataTest DIExpressionTest; TEST_F(DIExpressionTest, get) { uint64_t Elements[] = {2, 6, 9, 78, 0}; auto *N = DIExpression::get(Context, Elements); - EXPECT_EQ(makeArrayRef(Elements), N->getElements()); + EXPECT_EQ(ArrayRef(Elements), N->getElements()); EXPECT_EQ(N, DIExpression::get(Context, Elements)); EXPECT_EQ(5u, N->getNumElements()); diff --git a/llvm/unittests/Object/ELFTypesTest.cpp b/llvm/unittests/Object/ELFTypesTest.cpp index 183ef3e..265f8a7 100644 --- a/llvm/unittests/Object/ELFTypesTest.cpp +++ b/llvm/unittests/Object/ELFTypesTest.cpp @@ -43,7 +43,7 @@ template <class ELFT> struct NoteTestData { TEST(ELFTypesTest, NoteTest) { static const uint8_t Random[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - ArrayRef<uint8_t> RandomData = makeArrayRef(Random); + ArrayRef<uint8_t> RandomData = ArrayRef(Random); NoteTestData<ELF64LE> TestData; auto Note1 = TestData.getElfNote(StringRef("AMD"), ELF::NT_AMDGPU_METADATA, diff --git a/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp b/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp index a3c9e7e..0297f62 100644 --- a/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/MinidumpYAMLTest.cpp @@ -137,7 +137,7 @@ Streams: EXPECT_EQ(OSPlatform::Linux, SysInfo.PlatformId); EXPECT_EQ( (ArrayRef<uint8_t>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}), - makeArrayRef(SysInfo.CPU.Other.ProcessorFeatures)); + ArrayRef(SysInfo.CPU.Other.ProcessorFeatures)); } // Test that we can parse a normal-looking ExceptionStream. diff --git a/llvm/unittests/ProfileData/CoverageMappingTest.cpp b/llvm/unittests/ProfileData/CoverageMappingTest.cpp index 2791f678..884a76c 100644 --- a/llvm/unittests/ProfileData/CoverageMappingTest.cpp +++ b/llvm/unittests/ProfileData/CoverageMappingTest.cpp @@ -213,7 +213,7 @@ struct CoverageMappingTest : ::testing::TestWithParam<std::tuple<bool, bool>> { Filenames.resize(Files.size() + 1); for (const auto &E : Files) Filenames[E.getValue()] = E.getKey().str(); - ArrayRef<std::string> FilenameRefs = llvm::makeArrayRef(Filenames); + ArrayRef<std::string> FilenameRefs = llvm::ArrayRef(Filenames); RawCoverageMappingReader Reader(Coverage, FilenameRefs, Data.Filenames, Data.Expressions, Data.Regions); EXPECT_THAT_ERROR(Reader.read(), Succeeded()); @@ -279,7 +279,7 @@ TEST_P(CoverageMappingTest, basic_write_read) { InputFunctionCoverageData &Input = InputFunctions.back(); OutputFunctionCoverageData &Output = OutputFunctions.back(); - size_t N = makeArrayRef(Input.Regions).size(); + size_t N = ArrayRef(Input.Regions).size(); ASSERT_EQ(N, Output.Regions.size()); for (size_t I = 0; I < N; ++I) { ASSERT_EQ(Input.Regions[I].Count, Output.Regions[I].Count); diff --git a/llvm/unittests/ProfileData/InstrProfTest.cpp b/llvm/unittests/ProfileData/InstrProfTest.cpp index cbc04d2..86a7047 100644 --- a/llvm/unittests/ProfileData/InstrProfTest.cpp +++ b/llvm/unittests/ProfileData/InstrProfTest.cpp @@ -551,7 +551,7 @@ TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) { // Annotate with 4 records. InstrProfValueData VD0Sorted[] = {{1000, 6}, {2000, 5}, {3000, 4}, {4000, 3}, {5000, 2}, {6000, 1}}; - annotateValueSite(*M, *Inst, makeArrayRef(VD0Sorted).slice(2), 10, + annotateValueSite(*M, *Inst, ArrayRef(VD0Sorted).slice(2), 10, IPVK_IndirectCallTarget, 5); Res = getValueProfDataFromInst(*Inst, IPVK_IndirectCallTarget, 5, ValueData, N, T); diff --git a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp index fef1a93..442c24b 100644 --- a/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp +++ b/llvm/unittests/Remarks/YAMLRemarksSerializerTest.cpp @@ -55,7 +55,7 @@ static void check(remarks::Format SerializerFormat, const remarks::Remark &R, StringRef ExpectedR, StringRef ExpectedMeta, std::optional<remarks::StringTable> StrTab = std::nullopt) { return check(SerializerFormat, remarks::SerializerMode::Separate, - makeArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta, + ArrayRef(&R, &R + 1), ExpectedR, ExpectedMeta, std::move(StrTab)); } @@ -64,7 +64,7 @@ checkStandalone(remarks::Format SerializerFormat, const remarks::Remark &R, StringRef ExpectedR, std::optional<remarks::StringTable> StrTab = std::nullopt) { return check(SerializerFormat, remarks::SerializerMode::Standalone, - makeArrayRef(&R, &R + 1), ExpectedR, + ArrayRef(&R, &R + 1), ExpectedR, /*ExpectedMeta=*/std::nullopt, std::move(StrTab)); } diff --git a/llvm/unittests/Support/BinaryStreamTest.cpp b/llvm/unittests/Support/BinaryStreamTest.cpp index fdd29a7..01b49ca 100644 --- a/llvm/unittests/Support/BinaryStreamTest.cpp +++ b/llvm/unittests/Support/BinaryStreamTest.cpp @@ -46,7 +46,7 @@ public: uint8_t *Ptr = Allocator.Allocate<uint8_t>(Size); ::memcpy(Ptr, Ref.data(), Ref.size()); ::memcpy(Ptr + Ref.size(), Data.data(), BytesLeft); - Buffer = makeArrayRef<uint8_t>(Ptr, Size); + Buffer = ArrayRef<uint8_t>(Ptr, Size); return Error::success(); } @@ -203,9 +203,9 @@ TEST_F(BinaryStreamTest, BinaryByteStreamBounds) { // 1. If the read fits it should work. ASSERT_EQ(InputData.size(), Stream.Input->getLength()); ASSERT_THAT_ERROR(Stream.Input->readBytes(2, 1, Buffer), Succeeded()); - EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer); ASSERT_THAT_ERROR(Stream.Input->readBytes(0, 4, Buffer), Succeeded()); - EXPECT_EQ(makeArrayRef(InputData).slice(0, 4), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(0, 4), Buffer); // 2. Reading past the bounds of the input should fail. EXPECT_THAT_ERROR(Stream.Input->readBytes(4, 2, Buffer), Failed()); @@ -223,12 +223,12 @@ TEST_F(BinaryStreamTest, StreamRefBounds) { // Read 1 byte from offset 2 should work ASSERT_EQ(InputData.size(), Ref.getLength()); ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded()); - EXPECT_EQ(makeArrayRef(InputData).slice(2, 1), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(2, 1), Buffer); // Reading everything from offset 2 on. ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); if (Stream.IsContiguous) - EXPECT_EQ(makeArrayRef(InputData).slice(2), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(2), Buffer); else EXPECT_FALSE(Buffer.empty()); @@ -241,14 +241,14 @@ TEST_F(BinaryStreamTest, StreamRefBounds) { Ref = Ref.drop_front(1); ASSERT_THAT_ERROR(Ref.readBytes(2, 1, Buffer), Succeeded()); if (Stream.IsContiguous) - EXPECT_EQ(makeArrayRef(InputData).slice(3, 1), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(3, 1), Buffer); else EXPECT_FALSE(Buffer.empty()); // Reading everything from offset 2 on after dropping 1 byte. ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); if (Stream.IsContiguous) - EXPECT_EQ(makeArrayRef(InputData).slice(3), Buffer); + EXPECT_EQ(ArrayRef(InputData).slice(3), Buffer); else EXPECT_FALSE(Buffer.empty()); @@ -260,7 +260,7 @@ TEST_F(BinaryStreamTest, StreamRefBounds) { // But if we read the longest contiguous chunk instead, we should still // get the 1 byte at the end. ASSERT_THAT_ERROR(Ref.readLongestContiguousChunk(2, Buffer), Succeeded()); - EXPECT_EQ(makeArrayRef(InputData).take_back(), Buffer); + EXPECT_EQ(ArrayRef(InputData).take_back(), Buffer); } } @@ -316,7 +316,7 @@ TEST_F(BinaryStreamTest, StreamRefDynamicSize) { TEST_F(BinaryStreamTest, DropOperations) { std::vector<uint8_t> InputData = {1, 2, 3, 4, 5, 4, 3, 2, 1}; - auto RefData = makeArrayRef(InputData); + auto RefData = ArrayRef(InputData); initializeInput(InputData, 1); ArrayRef<uint8_t> Result; @@ -383,7 +383,7 @@ TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) { ArrayRef<uint8_t> Data2; ASSERT_THAT_ERROR(Stream.Output->readBytes(Offset, ExpectedSize, Data2), Succeeded()); - EXPECT_EQ(makeArrayRef(InputData).drop_front(Offset), Data2); + EXPECT_EQ(ArrayRef(InputData).drop_front(Offset), Data2); } std::vector<uint8_t> BigData = {0, 1, 2, 3, 4}; @@ -397,7 +397,7 @@ TEST_F(BinaryStreamTest, AppendingStream) { EXPECT_EQ(0U, Stream.getLength()); std::vector<uint8_t> InputData = {'T', 'e', 's', 't', 'T', 'e', 's', 't'}; - auto Test = makeArrayRef(InputData).take_front(4); + auto Test = ArrayRef(InputData).take_front(4); // Writing past the end of the stream is an error. EXPECT_THAT_ERROR(Stream.writeBytes(4, Test), Failed()); @@ -575,7 +575,7 @@ TEST_F(BinaryStreamTest, StreamReaderIntegerArray) { ArrayRef<int> IntsRef; ASSERT_THAT_ERROR(Reader.readArray(IntsRef, Ints.size()), Succeeded()); ASSERT_EQ(0U, Reader.bytesRemaining()); - EXPECT_EQ(makeArrayRef(Ints), IntsRef); + EXPECT_EQ(ArrayRef(Ints), IntsRef); Reader.setOffset(0); FixedStreamArray<int> FixedIntsRef; @@ -699,7 +699,7 @@ TEST_F(BinaryStreamTest, StreamReaderObject) { const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]); - initializeInput(makeArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo)); + initializeInput(ArrayRef(Bytes, 3 * sizeof(Foo)), alignof(Foo)); for (auto &Stream : Streams) { // 1. Reading object pointers. @@ -803,7 +803,7 @@ TEST_F(BinaryStreamTest, StreamWriterIntegerArrays) { ASSERT_THAT_ERROR(ReaderBacker.readArray(Ints2, SourceInts.size()), Succeeded()); - EXPECT_EQ(makeArrayRef(SourceInts), Ints2); + EXPECT_EQ(ArrayRef(SourceInts), Ints2); } } @@ -827,7 +827,7 @@ TEST_F(BinaryStreamTest, StreamWriterStrings) { ASSERT_THAT_ERROR(Reader.readCString(S), Succeeded()); InStrings.push_back(S); } - EXPECT_EQ(makeArrayRef(Strings), makeArrayRef(InStrings)); + EXPECT_EQ(ArrayRef(Strings), ArrayRef(InStrings)); } } diff --git a/llvm/unittests/Support/CRCTest.cpp b/llvm/unittests/Support/CRCTest.cpp index 32d2cf7..fb6dbc7 100644 --- a/llvm/unittests/Support/CRCTest.cpp +++ b/llvm/unittests/Support/CRCTest.cpp @@ -55,7 +55,7 @@ TEST(CRCTest, LargeCRC32) { // Test expectation generated with: // $ truncate --size=`echo 2^32-1+42 | bc` /tmp/foo // $ crc32 /tmp/foo - EXPECT_EQ(0xE46F28FBU, llvm::crc32(makeArrayRef(TestData, TestSize))); + EXPECT_EQ(0xE46F28FBU, llvm::crc32(ArrayRef(TestData, TestSize))); free(TestData); } diff --git a/llvm/unittests/Support/CommandLineTest.cpp b/llvm/unittests/Support/CommandLineTest.cpp index 0d0b6ec..b65d4bd 100644 --- a/llvm/unittests/Support/CommandLineTest.cpp +++ b/llvm/unittests/Support/CommandLineTest.cpp @@ -436,7 +436,7 @@ TEST(CommandLineTest, HideUnrelatedOptionsMulti) { const cl::OptionCategory *VisibleCategories[] = {&TestCategory, &TestCategory2}; - cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories)); + cl::HideUnrelatedOptions(ArrayRef(VisibleCategories)); ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag()) << "Failed to hide extra option."; diff --git a/llvm/unittests/Support/ConvertUTFTest.cpp b/llvm/unittests/Support/ConvertUTFTest.cpp index 8f172b7..6e75fba 100644 --- a/llvm/unittests/Support/ConvertUTFTest.cpp +++ b/llvm/unittests/Support/ConvertUTFTest.cpp @@ -75,7 +75,7 @@ TEST(ConvertUTFTest, ConvertUTF8ToUTF16String) { TEST(ConvertUTFTest, OddLengthInput) { std::string Result; - bool Success = convertUTF16ToUTF8String(makeArrayRef("xxxxx", 5), Result); + bool Success = convertUTF16ToUTF8String(ArrayRef("xxxxx", 5), Result); EXPECT_FALSE(Success); } @@ -88,25 +88,25 @@ TEST(ConvertUTFTest, Empty) { } TEST(ConvertUTFTest, HasUTF16BOM) { - bool HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xff\xfe", 2)); + bool HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xff\xfe", 2)); EXPECT_TRUE(HasBOM); - HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff", 2)); + HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff", 2)); EXPECT_TRUE(HasBOM); - HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff ", 3)); + HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff ", 3)); EXPECT_TRUE(HasBOM); // Don't care about odd lengths. - HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe\xff\x00asdf", 6)); + HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe\xff\x00asdf", 6)); EXPECT_TRUE(HasBOM); HasBOM = hasUTF16ByteOrderMark(std::nullopt); EXPECT_FALSE(HasBOM); - HasBOM = hasUTF16ByteOrderMark(makeArrayRef("\xfe", 1)); + HasBOM = hasUTF16ByteOrderMark(ArrayRef("\xfe", 1)); EXPECT_FALSE(HasBOM); } TEST(ConvertUTFTest, UTF16WrappersForConvertUTF16ToUTF8String) { // Src is the look of disapproval. alignas(UTF16) static const char Src[] = "\xff\xfe\xa0\x0c_\x00\xa0\x0c"; - ArrayRef<UTF16> SrcRef = makeArrayRef((const UTF16 *)Src, 4); + ArrayRef<UTF16> SrcRef = ArrayRef((const UTF16 *)Src, 4); std::string Result; bool Success = convertUTF16ToUTF8String(SrcRef, Result); EXPECT_TRUE(Success); diff --git a/llvm/unittests/Support/HashBuilderTest.cpp b/llvm/unittests/Support/HashBuilderTest.cpp index 2e27e4b..65d5146 100644 --- a/llvm/unittests/Support/HashBuilderTest.cpp +++ b/llvm/unittests/Support/HashBuilderTest.cpp @@ -102,7 +102,7 @@ TYPED_TEST(HashBuilderTest, AddHashableData) { constexpr auto E = HE::Endianness; H Hasher; auto SwappedData = llvm::support::endian::byte_swap(Data, E); - Hasher.update(llvm::makeArrayRef( + Hasher.update(llvm::ArrayRef( reinterpret_cast<const uint8_t *>(&SwappedData), sizeof(Data))); return Hasher.final(); }; @@ -157,8 +157,8 @@ struct /* __attribute__((packed)) */ StructWithFastHash { friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder, const StructWithFastHash &Value) { if (Endianness == llvm::support::endian::system_endianness()) { - HBuilder.update(llvm::makeArrayRef( - reinterpret_cast<const uint8_t *>(&Value), sizeof(Value))); + HBuilder.update(llvm::ArrayRef(reinterpret_cast<const uint8_t *>(&Value), + sizeof(Value))); } else { // Rely on existing `add` methods to handle endianness. HBuilder.add(Value.I); @@ -181,7 +181,7 @@ public: friend void addHash(llvm::HashBuilderImpl<HasherT, Endianness> &HBuilder, const CustomContainer &Value) { if (Endianness == llvm::support::endian::system_endianness()) { - HBuilder.update(llvm::makeArrayRef( + HBuilder.update(llvm::ArrayRef( reinterpret_cast<const uint8_t *>(&Value.Size), sizeof(Value.Size) + Value.Size * sizeof(Value.Elements[0]))); } else { diff --git a/llvm/unittests/Support/IndexedAccessorTest.cpp b/llvm/unittests/Support/IndexedAccessorTest.cpp index 02b5656..99986de 100644 --- a/llvm/unittests/Support/IndexedAccessorTest.cpp +++ b/llvm/unittests/Support/IndexedAccessorTest.cpp @@ -39,7 +39,7 @@ static void compareData(ArrayIndexedAccessorRange<T> range, namespace { TEST(AccessorRange, SliceTest) { int rawData[] = {0, 1, 2, 3, 4}; - ArrayRef<int> data = llvm::makeArrayRef(rawData); + ArrayRef<int> data = llvm::ArrayRef(rawData); ArrayIndexedAccessorRange<int> range(rawData, /*start=*/0, /*numElements=*/5); compareData(range, data); diff --git a/llvm/unittests/Support/MD5Test.cpp b/llvm/unittests/Support/MD5Test.cpp index 83c556c..9742e1b 100644 --- a/llvm/unittests/Support/MD5Test.cpp +++ b/llvm/unittests/Support/MD5Test.cpp @@ -40,20 +40,20 @@ void TestMD5Sum(StringRef Input, StringRef Final) { } TEST(MD5Test, MD5) { - TestMD5Sum(makeArrayRef((const uint8_t *)"", (size_t) 0), + TestMD5Sum(ArrayRef((const uint8_t *)"", (size_t)0), "d41d8cd98f00b204e9800998ecf8427e"); - TestMD5Sum(makeArrayRef((const uint8_t *)"a", (size_t) 1), + TestMD5Sum(ArrayRef((const uint8_t *)"a", (size_t)1), "0cc175b9c0f1b6a831c399e269772661"); - TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", - (size_t) 26), - "c3fcd3d76192e4007dfb496cca67e13b"); - TestMD5Sum(makeArrayRef((const uint8_t *)"\0", (size_t) 1), + TestMD5Sum( + ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz", (size_t)26), + "c3fcd3d76192e4007dfb496cca67e13b"); + TestMD5Sum(ArrayRef((const uint8_t *)"\0", (size_t)1), "93b885adfe0da089cdf634904fd59f71"); - TestMD5Sum(makeArrayRef((const uint8_t *)"a\0", (size_t) 2), + TestMD5Sum(ArrayRef((const uint8_t *)"a\0", (size_t)2), "4144e195f46de78a3623da7364d04f11"); - TestMD5Sum(makeArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0", - (size_t) 27), - "81948d1f1554f58cd1a56ebb01f808cb"); + TestMD5Sum( + ArrayRef((const uint8_t *)"abcdefghijklmnopqrstuvwxyz\0", (size_t)27), + "81948d1f1554f58cd1a56ebb01f808cb"); TestMD5Sum("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b"); } diff --git a/llvm/unittests/Support/ScopedPrinterTest.cpp b/llvm/unittests/Support/ScopedPrinterTest.cpp index d959720..5afb796 100644 --- a/llvm/unittests/Support/ScopedPrinterTest.cpp +++ b/llvm/unittests/Support/ScopedPrinterTest.cpp @@ -226,8 +226,8 @@ TEST_F(ScopedPrinterTest, PrintEnum) { {"Name3", "AltName3", 3}, {"Name4", "AltName4", 2}}; EnumEntry<int> OtherEnum{"Name5", "AltName5", 5}; - W.printEnum("Exists", EnumList[1].Value, makeArrayRef(EnumList)); - W.printEnum("DoesNotExist", OtherEnum.Value, makeArrayRef(EnumList)); + W.printEnum("Exists", EnumList[1].Value, ArrayRef(EnumList)); + W.printEnum("DoesNotExist", OtherEnum.Value, ArrayRef(EnumList)); }; const char *ExpectedOut = R"(Exists: Name2 (0x2) @@ -259,11 +259,10 @@ TEST_F(ScopedPrinterTest, PrintFlag) { {"SecondByte2", "Second2", 0x20u}, {"SecondByte3", "Second3", 0x30u}, {"ThirdByte1", "Third1", 0x100u}, {"ThirdByte2", "Third2", 0x200u}, {"ThirdByte3", "Third3", 0x300u}}; - W.printFlags("ZeroFlag", 0, makeArrayRef(SingleBitFlags)); - W.printFlags("NoFlag", 1 << 3, makeArrayRef(SingleBitFlags)); - W.printFlags("Flag1", SingleBitFlags[1].Value, - makeArrayRef(SingleBitFlags)); - W.printFlags("Flag1&3", (1 << 2) + 1, makeArrayRef(SingleBitFlags)); + W.printFlags("ZeroFlag", 0, ArrayRef(SingleBitFlags)); + W.printFlags("NoFlag", 1 << 3, ArrayRef(SingleBitFlags)); + W.printFlags("Flag1", SingleBitFlags[1].Value, ArrayRef(SingleBitFlags)); + W.printFlags("Flag1&3", (1 << 2) + 1, ArrayRef(SingleBitFlags)); W.printFlags("ZeroFlagRaw", 0); W.printFlags("NoFlagRaw", 1 << 3); @@ -271,21 +270,19 @@ TEST_F(ScopedPrinterTest, PrintFlag) { W.printFlags("Flag1&3Raw", (1 << 2) + 1); W.printFlags("FlagSorted", (1 << 2) + (1 << 1) + 1, - makeArrayRef(UnsortedFlags)); + ArrayRef(UnsortedFlags)); uint16_t NoBitMask = 0; uint16_t FirstByteMask = 0xFu; uint16_t SecondByteMask = 0xF0u; uint16_t ThirdByteMask = 0xF00u; - W.printFlags("NoBitMask", 0xFFFu, makeArrayRef(EnumFlags), NoBitMask); - W.printFlags("FirstByteMask", 0x3u, makeArrayRef(EnumFlags), FirstByteMask); - W.printFlags("SecondByteMask", 0x30u, makeArrayRef(EnumFlags), - SecondByteMask); - W.printFlags("ValueOutsideMask", 0x1u, makeArrayRef(EnumFlags), - SecondByteMask); - W.printFlags("FirstSecondByteMask", 0xFFu, makeArrayRef(EnumFlags), + W.printFlags("NoBitMask", 0xFFFu, ArrayRef(EnumFlags), NoBitMask); + W.printFlags("FirstByteMask", 0x3u, ArrayRef(EnumFlags), FirstByteMask); + W.printFlags("SecondByteMask", 0x30u, ArrayRef(EnumFlags), SecondByteMask); + W.printFlags("ValueOutsideMask", 0x1u, ArrayRef(EnumFlags), SecondByteMask); + W.printFlags("FirstSecondByteMask", 0xFFu, ArrayRef(EnumFlags), FirstByteMask, SecondByteMask); - W.printFlags("FirstSecondThirdByteMask", 0x333u, makeArrayRef(EnumFlags), + W.printFlags("FirstSecondThirdByteMask", 0x333u, ArrayRef(EnumFlags), FirstByteMask, SecondByteMask, ThirdByteMask); }; @@ -662,7 +659,7 @@ TEST_F(ScopedPrinterTest, PrintList) { APSInt("-9999999999999999999999")}; W.printList("EmptyList", EmptyList); W.printList("StringList", StringList); - W.printList("BoolList", makeArrayRef(BoolList)); + W.printList("BoolList", ArrayRef(BoolList)); W.printList("uint64List", Unsigned64List); W.printList("uint32List", Unsigned32List); W.printList("uint16List", Unsigned16List); diff --git a/llvm/unittests/Support/SourceMgrTest.cpp b/llvm/unittests/Support/SourceMgrTest.cpp index 1cce649..cbd17ff 100644 --- a/llvm/unittests/Support/SourceMgrTest.cpp +++ b/llvm/unittests/Support/SourceMgrTest.cpp @@ -511,7 +511,7 @@ TEST_F(SourceMgrTest, OverlappingRanges) { TEST_F(SourceMgrTest, BasicFixit) { setMainBuffer("aaa bbb\nccc ddd\n", "file.in"); printMessage(getLoc(4), SourceMgr::DK_Error, "message", std::nullopt, - makeArrayRef(SMFixIt(getRange(4, 3), "zzz"))); + ArrayRef(SMFixIt(getRange(4, 3), "zzz"))); EXPECT_EQ("file.in:1:5: error: message\n" "aaa bbb\n" @@ -523,7 +523,7 @@ TEST_F(SourceMgrTest, BasicFixit) { TEST_F(SourceMgrTest, FixitForTab) { setMainBuffer("aaa\tbbb\nccc ddd\n", "file.in"); printMessage(getLoc(3), SourceMgr::DK_Error, "message", std::nullopt, - makeArrayRef(SMFixIt(getRange(3, 1), "zzz"))); + ArrayRef(SMFixIt(getRange(3, 1), "zzz"))); EXPECT_EQ("file.in:1:4: error: message\n" "aaa bbb\n" diff --git a/llvm/unittests/TableGen/AutomataTest.cpp b/llvm/unittests/TableGen/AutomataTest.cpp index fb19716..53f6612 100644 --- a/llvm/unittests/TableGen/AutomataTest.cpp +++ b/llvm/unittests/TableGen/AutomataTest.cpp @@ -30,7 +30,7 @@ using testing::UnorderedElementsAre; #include "AutomataAutomata.inc" TEST(Automata, SimpleAutomatonAcceptsFromInitialState) { - Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions)); + Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)}; EXPECT_TRUE(A.add(SK_a)); A.reset(); EXPECT_TRUE(A.add(SK_b)); @@ -41,7 +41,7 @@ TEST(Automata, SimpleAutomatonAcceptsFromInitialState) { } TEST(Automata, SimpleAutomatonAcceptsSequences) { - Automaton<SymKind> A(makeArrayRef(SimpleAutomatonTransitions)); + Automaton<SymKind> A{ArrayRef(SimpleAutomatonTransitions)}; // Test sequence <a b> A.reset(); EXPECT_TRUE(A.add(SK_a)); @@ -59,7 +59,7 @@ TEST(Automata, SimpleAutomatonAcceptsSequences) { } TEST(Automata, TupleAutomatonAccepts) { - Automaton<TupleAutomatonAction> A(makeArrayRef(TupleAutomatonTransitions)); + Automaton<TupleAutomatonAction> A{ArrayRef(TupleAutomatonTransitions)}; A.reset(); EXPECT_TRUE( A.add(TupleAutomatonAction{SK_a, SK_b, "yeet"})); @@ -75,7 +75,7 @@ TEST(Automata, TupleAutomatonAccepts) { } TEST(Automata, NfaAutomatonAccepts) { - Automaton<SymKind> A(makeArrayRef(NfaAutomatonTransitions)); + Automaton<SymKind> A{ArrayRef(NfaAutomatonTransitions)}; // Test sequences <a a>, <a b>, <b a>, <b b>. All should be accepted. A.reset(); @@ -99,7 +99,8 @@ TEST(Automata, NfaAutomatonAccepts) { } TEST(Automata, BinPackerAutomatonAccepts) { - Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions)); + Automaton<BinPackerAutomatonAction> A{ + ArrayRef(BinPackerAutomatonTransitions)}; // Expect that we can pack two double-bins in 0-4, then no more in 0-4. A.reset(); @@ -129,8 +130,9 @@ TEST(Automata, BinPackerAutomatonAccepts) { ((a << 5) | (b << 4) | (c << 3) | (d << 2) | (e << 1) | (f << 0)) TEST(Automata, BinPackerAutomatonExplains) { - Automaton<BinPackerAutomatonAction> A(makeArrayRef(BinPackerAutomatonTransitions), - makeArrayRef(BinPackerAutomatonTransitionInfo)); + Automaton<BinPackerAutomatonAction> A{ + ArrayRef(BinPackerAutomatonTransitions), + ArrayRef(BinPackerAutomatonTransitionInfo)}; // Pack two double-bins in 0-4, then a single bin in 0-6. EXPECT_TRUE(A.add(BRK_0_to_4_dbl)); EXPECT_TRUE(A.add(BRK_0_to_4_dbl)); diff --git a/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp b/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp index 9605d93..52e04db 100644 --- a/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp +++ b/llvm/unittests/Target/AArch64/AArch64InstPrinterTest.cpp @@ -37,9 +37,9 @@ static std::string AArch64InstPrinterTestPrintAlignedLabel(uint64_t value) { MCInstrInfo MII; MCRegisterInfo MRI; MCSubtargetInfo STI(Triple(""), "", "", "", - makeArrayRef((SubtargetFeatureKV *)NULL, 0), - makeArrayRef((SubtargetSubTypeKV *)NULL, 0), NULL, NULL, - NULL, NULL, NULL, NULL); + ArrayRef((SubtargetFeatureKV *)NULL, (size_t)0), + ArrayRef((SubtargetSubTypeKV *)NULL, (size_t)0), NULL, + NULL, NULL, NULL, NULL, NULL); MCContext Ctx(Triple(""), &MAI, &MRI, &STI); MCInst MI; |